This is the major component of ioredis. Use it to connect to a standalone Redis server or Sentinels.

const redis = new Redis(); // Default port is 6379
async function main() {
redis.set("foo", "bar");
redis.get("foo", (err, result) => {
// `result` should be "bar"
console.log(err, result);
});
// Or use Promise
const result = await redis.get("foo");
}

Hierarchy

  • Commander
  • EventEmitter
  • Transaction
    • Redis

Implements

  • DataHandledable

Constructors

Properties

Accessors

Methods

[captureRejectionSymbol]? acl aclBuffer addBuiltinCommand addListener append asking auth bgrewriteaof bgrewriteaofBuffer bgsave bitcount bitfield bitfield_ro bitop bitpos blmove blmoveBuffer blmpop blmpopBuffer blpop blpopBuffer brpop brpopBuffer brpoplpush brpoplpushBuffer bzmpop bzpopmax bzpopmaxBuffer bzpopmin bzpopminBuffer call callBuffer client clientBuffer cluster command config connect copy createBuiltinCommand dbsize debug decr decrby defineCommand del discard disconnect dump dumpBuffer duplicate echo echoBuffer emit end eval eval_ro evalsha evalsha_ro eventNames exec exists expire expireat expiretime failover fcall fcall_ro flushall flushdb function functionBuffer geoadd geodist geodistBuffer geohash geohashBuffer geopos georadius georadius_ro georadiusbymember georadiusbymember_ro geosearch geosearchstore get getbit getBuffer getBuiltinCommands getdel getdelBuffer getex getexBuffer getMaxListeners getrange getrangeBuffer getset getsetBuffer hdel hello hexists hget hgetall hgetallBuffer hgetBuffer hincrby hincrbyfloat hincrbyfloatBuffer hkeys hkeysBuffer hlen hmget hmgetBuffer hmset hrandfield hrandfieldBuffer hscan hscanBuffer hscanBufferStream hscanStream hset hsetnx hstrlen hvals hvalsBuffer incr incrby incrbyfloat info keys keysBuffer lastsave latency lcs lindex lindexBuffer linsert listenerCount listeners llen lmove lmoveBuffer lmpop lmpopBuffer lolwut lpop lpopBuffer lpos lpush lpushx lrange lrangeBuffer lrem lset ltrim memory mget mgetBuffer migrate module monitor move mset msetnx multi object off on once persist pexpire pexpireat pexpiretime pfadd pfcount pfdebug pfmerge pfselftest ping pingBuffer pipeline prependListener prependOnceListener psetex psubscribe psync pttl publish pubsub punsubscribe quit randomkey randomkeyBuffer rawListeners readonly readwrite removeAllListeners removeListener rename renamenx replconf replicaof reset restore restore-asking role rpop rpopBuffer rpoplpush rpoplpushBuffer rpush rpushx sadd save scan scanBuffer scanBufferStream scanStream scard script sdiff sdiffBuffer sdiffstore select set setbit setBuffer setex setMaxListeners setnx setrange shutdown sinter sinterBuffer sintercard sinterstore sismember slaveof slowlog smembers smembersBuffer smismember smove sort sort_ro spop spopBuffer spublish srandmember srandmemberBuffer srem sscan sscanBuffer sscanBufferStream sscanStream ssubscribe strlen subscribe substr sunion sunionBuffer sunionstore sunsubscribe swapdb sync time touch ttl type unlink unsubscribe unwatch wait watch xack xadd xaddBuffer xautoclaim xclaim xdel xgroup xinfo xlen xpending xrange xrangeBuffer xread xreadBuffer xreadgroup xrevrange xrevrangeBuffer xsetid xtrim zadd zaddBuffer zcard zcount zdiff zdiffBuffer zdiffstore zincrby zincrbyBuffer zinter zinterBuffer zintercard zinterstore zlexcount zmpop zmscore zmscoreBuffer zpopmax zpopmaxBuffer zpopmin zpopminBuffer zrandmember zrandmemberBuffer zrange zrangeBuffer zrangebylex zrangebylexBuffer zrangebyscore zrangebyscoreBuffer zrangestore zrank zrem zremrangebylex zremrangebyrank zremrangebyscore zrevrange zrevrangeBuffer zrevrangebylex zrevrangebylexBuffer zrevrangebyscore zrevrangebyscoreBuffer zrevrank zscan zscanBuffer zscanBufferStream zscanStream zscore zscoreBuffer zunion zunionBuffer zunionstore createClient

Constructors

  • Parameters

    Returns Redis

  • Parameters

    Returns Redis

  • Parameters

    Returns Redis

  • Parameters

    • port: number
    • host: string

    Returns Redis

  • Parameters

    Returns Redis

  • Parameters

    • port: number

    Returns Redis

  • Parameters

    • path: string

    Returns Redis

  • Returns Redis

Properties

options: RedisOptions
status: RedisStatus
Cluster: typeof Cluster
Command: typeof default

Accessors

  • get autoPipelineQueueSize(): number
  • Returns number

  • get mode(): "normal" | "subscriber" | "monitor"
  • Mode of the connection.

    One of "normal", "subscriber", or "monitor". When the connection is not in "normal" mode, certain commands are not allowed.

    Returns "normal" | "subscriber" | "monitor"

Methods

  • Type Parameters

    • K

    Parameters

    • error: Error
    • event: string | symbol
    • Rest...args: AnyRest

    Returns void

  • List the ACL categories or the commands inside a category

    • group: server
    • complexity: O(1) since the categories and commands are a fixed set.
    • since: 6.0.0

    Parameters

    • subcommand: "CAT"
    • Optionalcallback: Callback<unknown>

    Returns Promise<unknown>

  • Parameters

    • subcommand: "CAT"
    • categoryname: string | Buffer
    • Optionalcallback: Callback<unknown>

    Returns Promise<unknown>

  • Remove the specified ACL users and the associated rules

    • group: server
    • complexity: O(1) amortized time considering the typical user.
    • since: 6.0.0

    Parameters

    • Rest...args: [subcommand: "DELUSER", ...usernames: (string | Buffer)[], callback: Callback<number>]

    Returns Promise<number>

  • Parameters

    • Rest...args: [subcommand: "DELUSER", ...usernames: (string | Buffer)[]]

    Returns Promise<number>

  • Returns whether the user can execute the given command without executing the command.

    • group: server
    • complexity: O(1).
    • since: 7.0.0

    Parameters

    • subcommand: "DRYRUN"
    • username: string | Buffer
    • command: string | Buffer
    • Optionalcallback: Callback<string>

    Returns Promise<string>

  • Parameters

    • Rest...args: [subcommand: "DRYRUN", username: string | Buffer, command: string | Buffer, ...args: (string | number | Buffer)[], callback: Callback<string>]

    Returns Promise<string>

  • Parameters

    • Rest...args: [subcommand: "DRYRUN", username: string | Buffer, command: string | Buffer, ...args: (string | number | Buffer)[]]

    Returns Promise<string>

  • Generate a pseudorandom secure password to use for ACL users

    • group: server
    • complexity: O(1)
    • since: 6.0.0

    Parameters

    • subcommand: "GENPASS"
    • Optionalcallback: Callback<string>

    Returns Promise<string>

  • Parameters

    • subcommand: "GENPASS"
    • bits: string | number
    • Optionalcallback: Callback<string>

    Returns Promise<string>

  • Get the rules for a specific ACL user

    • group: server
    • complexity: O(N). Where N is the number of password, command and pattern rules that the user has.
    • since: 6.0.0

    Parameters

    • subcommand: "GETUSER"
    • username: string | Buffer
    • Optionalcallback: Callback<null | string[]>

    Returns Promise<null | string[]>

  • Show helpful text about the different subcommands

    • group: server
    • complexity: O(1)
    • since: 6.0.0

    Parameters

    • subcommand: "HELP"
    • Optionalcallback: Callback<unknown>

    Returns Promise<unknown>

  • List the current ACL rules in ACL config file format

    • group: server
    • complexity: O(N). Where N is the number of configured users.
    • since: 6.0.0

    Parameters

    • subcommand: "LIST"
    • Optionalcallback: Callback<string[]>

    Returns Promise<string[]>

  • Reload the ACLs from the configured ACL file

    • group: server
    • complexity: O(N). Where N is the number of configured users.
    • since: 6.0.0

    Parameters

    • subcommand: "LOAD"
    • Optionalcallback: Callback<"OK">

    Returns Promise<"OK">

  • List latest events denied because of ACLs in place

    • group: server
    • complexity: O(N) with N being the number of entries shown.
    • since: 6.0.0

    Parameters

    • subcommand: "LOG"
    • Optionalcallback: Callback<unknown>

    Returns Promise<unknown>

  • Parameters

    • subcommand: "LOG"
    • count: string | number
    • Optionalcallback: Callback<unknown>

    Returns Promise<unknown>

  • Parameters

    • subcommand: "LOG"
    • reset: "RESET"
    • Optionalcallback: Callback<unknown>

    Returns Promise<unknown>

  • Save the current ACL rules in the configured ACL file

    • group: server
    • complexity: O(N). Where N is the number of configured users.
    • since: 6.0.0

    Parameters

    • subcommand: "SAVE"
    • Optionalcallback: Callback<"OK">

    Returns Promise<"OK">

  • Modify or create the rules for a specific ACL user

    • group: server
    • complexity: O(N). Where N is the number of rules provided.
    • since: 6.0.0

    Parameters

    • subcommand: "SETUSER"
    • username: string | Buffer
    • Optionalcallback: Callback<"OK">

    Returns Promise<"OK">

  • Parameters

    • Rest...args: [subcommand: "SETUSER", username: string | Buffer, ...rules: (string | Buffer)[], callback: Callback<"OK">]

    Returns Promise<"OK">

  • Parameters

    • Rest...args: [subcommand: "SETUSER", username: string | Buffer, ...rules: (string | Buffer)[]]

    Returns Promise<"OK">

  • List the username of all the configured ACL rules

    • group: server
    • complexity: O(N). Where N is the number of configured users.
    • since: 6.0.0

    Parameters

    • subcommand: "USERS"
    • Optionalcallback: Callback<string[]>

    Returns Promise<string[]>

  • Return the name of the user associated to the current connection

    • group: server
    • complexity: O(1)
    • since: 6.0.0

    Parameters

    • subcommand: "WHOAMI"
    • Optionalcallback: Callback<string>

    Returns Promise<string>

  • Parameters

    • subcommand: "DRYRUN"
    • username: string | Buffer
    • command: string | Buffer
    • Optionalcallback: Callback<Buffer>

    Returns Promise<Buffer>

  • Parameters

    • Rest...args: [subcommand: "DRYRUN", username: string | Buffer, command: string | Buffer, ...args: (string | number | Buffer)[], callback: Callback<Buffer>]

    Returns Promise<Buffer>

  • Parameters

    • Rest...args: [subcommand: "DRYRUN", username: string | Buffer, command: string | Buffer, ...args: (string | number | Buffer)[]]

    Returns Promise<Buffer>

  • Parameters

    • subcommand: "GENPASS"
    • Optionalcallback: Callback<Buffer>

    Returns Promise<Buffer>

  • Parameters

    • subcommand: "GENPASS"
    • bits: string | number
    • Optionalcallback: Callback<Buffer>

    Returns Promise<Buffer>

  • Parameters

    • subcommand: "GETUSER"
    • username: string | Buffer
    • Optionalcallback: Callback<null | Buffer[]>

    Returns Promise<null | Buffer[]>

  • Parameters

    • subcommand: "LIST"
    • Optionalcallback: Callback<Buffer[]>

    Returns Promise<Buffer[]>

  • Parameters

    • subcommand: "USERS"
    • Optionalcallback: Callback<Buffer[]>

    Returns Promise<Buffer[]>

  • Parameters

    • subcommand: "WHOAMI"
    • Optionalcallback: Callback<Buffer>

    Returns Promise<Buffer>

  • Create add builtin command

    Parameters

    • commandName: string

    Returns void

  • Alias for emitter.on(eventName, listener).

    Type Parameters

    • K

    Parameters

    • eventName: string | symbol
    • listener: ((...args: any[]) => void)
        • (...args): void
        • Parameters

          • Rest...args: any[]

          Returns void

    Returns this

    v0.1.26

  • Append a value to a key

    • group: string
    • complexity: O(1). The amortized time complexity is O(1) assuming the appended value is small and the already present value is of any size, since the dynamic string library used by Redis will double the free space available on every reallocation.
    • since: 2.0.0

    Parameters

    • key: RedisKey
    • value: string | number | Buffer
    • Optionalcallback: Callback<number>

    Returns Promise<number>

  • Sent by cluster clients after an -ASK redirect

    • group: cluster
    • complexity: O(1)
    • since: 3.0.0

    Parameters

    • Optionalcallback: Callback<"OK">

    Returns Promise<"OK">

  • Authenticate to the server

    • group: connection
    • complexity: O(N) where N is the number of passwords defined for the user
    • since: 1.0.0

    Parameters

    • password: string | Buffer
    • Optionalcallback: Callback<"OK">

    Returns Promise<"OK">

  • Parameters

    • username: string | Buffer
    • password: string | Buffer
    • Optionalcallback: Callback<"OK">

    Returns Promise<"OK">

  • Asynchronously rewrite the append-only file

    • group: server
    • complexity: O(1)
    • since: 1.0.0

    Parameters

    • Optionalcallback: Callback<string>

    Returns Promise<string>

  • Parameters

    • Optionalcallback: Callback<Buffer>

    Returns Promise<Buffer>

  • Asynchronously save the dataset to disk

    • group: server
    • complexity: O(1)
    • since: 1.0.0

    Parameters

    • Optionalcallback: Callback<"OK">

    Returns Promise<"OK">

  • Parameters

    • schedule: "SCHEDULE"
    • Optionalcallback: Callback<"OK">

    Returns Promise<"OK">

  • Count set bits in a string

    • group: bitmap
    • complexity: O(N)
    • since: 2.6.0

    Parameters

    • key: RedisKey
    • Optionalcallback: Callback<number>

    Returns Promise<number>

  • Parameters

    • key: RedisKey
    • start: string | number
    • end: string | number
    • Optionalcallback: Callback<number>

    Returns Promise<number>

  • Parameters

    • key: RedisKey
    • start: string | number
    • end: string | number
    • byte: "BYTE"
    • Optionalcallback: Callback<number>

    Returns Promise<number>

  • Parameters

    • key: RedisKey
    • start: string | number
    • end: string | number
    • bit: "BIT"
    • Optionalcallback: Callback<number>

    Returns Promise<number>

  • Perform arbitrary bitfield integer operations on strings

    • group: bitmap
    • complexity: O(1) for each subcommand specified
    • since: 3.2.0

    Parameters

    • key: RedisKey
    • encodingOffsetToken: "GET"
    • encoding: string | Buffer
    • offset: string | number
    • Optionalcallback: Callback<unknown>

    Returns Promise<unknown>

  • Parameters

    • key: RedisKey
    • encodingOffsetValueToken: "SET"
    • encoding: string | Buffer
    • offset: string | number
    • value: string | number
    • Optionalcallback: Callback<unknown>

    Returns Promise<unknown>

  • Parameters

    • key: RedisKey
    • encodingOffsetIncrementToken: "INCRBY"
    • encoding: string | Buffer
    • offset: string | number
    • increment: string | number
    • Optionalcallback: Callback<unknown>

    Returns Promise<unknown>

  • Parameters

    • key: RedisKey
    • overflow: "OVERFLOW"
    • wrap: "WRAP"
    • encodingOffsetValueToken: "SET"
    • encoding: string | Buffer
    • offset: string | number
    • value: string | number
    • Optionalcallback: Callback<unknown>

    Returns Promise<unknown>

  • Parameters

    • key: RedisKey
    • overflow: "OVERFLOW"
    • wrap: "WRAP"
    • encodingOffsetIncrementToken: "INCRBY"
    • encoding: string | Buffer
    • offset: string | number
    • increment: string | number
    • Optionalcallback: Callback<unknown>

    Returns Promise<unknown>

  • Parameters

    • key: RedisKey
    • overflow: "OVERFLOW"
    • sat: "SAT"
    • encodingOffsetValueToken: "SET"
    • encoding: string | Buffer
    • offset: string | number
    • value: string | number
    • Optionalcallback: Callback<unknown>

    Returns Promise<unknown>

  • Parameters

    • key: RedisKey
    • overflow: "OVERFLOW"
    • sat: "SAT"
    • encodingOffsetIncrementToken: "INCRBY"
    • encoding: string | Buffer
    • offset: string | number
    • increment: string | number
    • Optionalcallback: Callback<unknown>

    Returns Promise<unknown>

  • Parameters

    • key: RedisKey
    • overflow: "OVERFLOW"
    • fail: "FAIL"
    • encodingOffsetValueToken: "SET"
    • encoding: string | Buffer
    • offset: string | number
    • value: string | number
    • Optionalcallback: Callback<unknown>

    Returns Promise<unknown>

  • Parameters

    • key: RedisKey
    • overflow: "OVERFLOW"
    • fail: "FAIL"
    • encodingOffsetIncrementToken: "INCRBY"
    • encoding: string | Buffer
    • offset: string | number
    • increment: string | number
    • Optionalcallback: Callback<unknown>

    Returns Promise<unknown>

  • Perform arbitrary bitfield integer operations on strings. Read-only variant of BITFIELD

    • group: bitmap
    • complexity: O(1) for each subcommand specified
    • since: 6.0.0

    Parameters

    • Rest...args: [key: RedisKey, encodingOffsetToken: "GET", ...encodingOffsets: (string | number | Buffer)[], callback: Callback<unknown[]>]

    Returns Promise<unknown[]>

  • Parameters

    • Rest...args: [key: RedisKey, encodingOffsetToken: "GET", ...encodingOffsets: (string | number | Buffer)[]]

    Returns Promise<unknown[]>

  • Perform bitwise operations between strings

    • group: bitmap
    • complexity: O(N)
    • since: 2.6.0

    Parameters

    • Rest...args: [operation: string | Buffer, destkey: RedisKey, ...keys: RedisKey[], callback: Callback<number>]

    Returns Promise<number>

  • Parameters

    • Rest...args: [operation: string | Buffer, destkey: RedisKey, keys: RedisKey[], callback: Callback<number>]

    Returns Promise<number>

  • Parameters

    • Rest...args: [operation: string | Buffer, destkey: RedisKey, ...keys: RedisKey[]]

    Returns Promise<number>

  • Parameters

    • Rest...args: [operation: string | Buffer, destkey: RedisKey, keys: RedisKey[]]

    Returns Promise<number>

  • Find first bit set or clear in a string

    • group: bitmap
    • complexity: O(N)
    • since: 2.8.7

    Parameters

    • key: RedisKey
    • bit: string | number
    • Optionalcallback: Callback<number>

    Returns Promise<number>

  • Parameters

    • key: RedisKey
    • bit: string | number
    • start: string | number
    • Optionalcallback: Callback<number>

    Returns Promise<number>

  • Parameters

    • key: RedisKey
    • bit: string | number
    • start: string | number
    • end: string | number
    • Optionalcallback: Callback<number>

    Returns Promise<number>

  • Parameters

    • key: RedisKey
    • bit: string | number
    • start: string | number
    • end: string | number
    • byte: "BYTE"
    • Optionalcallback: Callback<number>

    Returns Promise<number>

  • Parameters

    • key: RedisKey
    • bit: string | number
    • start: string | number
    • end: string | number
    • bit1: "BIT"
    • Optionalcallback: Callback<number>

    Returns Promise<number>

  • Pop an element from a list, push it to another list and return it; or block until one is available

    • group: list
    • complexity: O(1)
    • since: 6.2.0

    Parameters

    • source: RedisKey
    • destination: RedisKey
    • left: "LEFT"
    • left1: "LEFT"
    • timeout: string | number
    • Optionalcallback: Callback<null | string>

    Returns Promise<null | string>

  • Parameters

    • source: RedisKey
    • destination: RedisKey
    • left: "LEFT"
    • right: "RIGHT"
    • timeout: string | number
    • Optionalcallback: Callback<null | string>

    Returns Promise<null | string>

  • Parameters

    • source: RedisKey
    • destination: RedisKey
    • right: "RIGHT"
    • left: "LEFT"
    • timeout: string | number
    • Optionalcallback: Callback<null | string>

    Returns Promise<null | string>

  • Parameters

    • source: RedisKey
    • destination: RedisKey
    • right: "RIGHT"
    • right1: "RIGHT"
    • timeout: string | number
    • Optionalcallback: Callback<null | string>

    Returns Promise<null | string>

  • Parameters

    • source: RedisKey
    • destination: RedisKey
    • left: "LEFT"
    • left1: "LEFT"
    • timeout: string | number
    • Optionalcallback: Callback<null | Buffer>

    Returns Promise<null | Buffer>

  • Parameters

    • source: RedisKey
    • destination: RedisKey
    • left: "LEFT"
    • right: "RIGHT"
    • timeout: string | number
    • Optionalcallback: Callback<null | Buffer>

    Returns Promise<null | Buffer>

  • Parameters

    • source: RedisKey
    • destination: RedisKey
    • right: "RIGHT"
    • left: "LEFT"
    • timeout: string | number
    • Optionalcallback: Callback<null | Buffer>

    Returns Promise<null | Buffer>

  • Parameters

    • source: RedisKey
    • destination: RedisKey
    • right: "RIGHT"
    • right1: "RIGHT"
    • timeout: string | number
    • Optionalcallback: Callback<null | Buffer>

    Returns Promise<null | Buffer>

  • Pop elements from a list, or block until one is available

    • group: list
    • complexity: O(N+M) where N is the number of provided keys and M is the number of elements returned.
    • since: 7.0.0

    Parameters

    • Rest...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], left: "LEFT", callback: Callback<null | [key: string, members: string[]]>]

    Returns Promise<null | [key: string, members: string[]]>

  • Parameters

    • Rest...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], left: "LEFT", callback: Callback<null | [key: string, members: string[]]>]

    Returns Promise<null | [key: string, members: string[]]>

  • Parameters

    • Rest...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], left: "LEFT"]

    Returns Promise<null | [key: string, members: string[]]>

  • Parameters

    • Rest...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], left: "LEFT"]

    Returns Promise<null | [key: string, members: string[]]>

  • Parameters

    • Rest...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], left: "LEFT", countToken: "COUNT", count: string | number, callback: Callback<null | [key: string, members: string[]]>]

    Returns Promise<null | [key: string, members: string[]]>

  • Parameters

    • Rest...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], left: "LEFT", countToken: "COUNT", count: string | number, callback: Callback<null | [key: string, members: string[]]>]

    Returns Promise<null | [key: string, members: string[]]>

  • Parameters

    • Rest...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], left: "LEFT", countToken: "COUNT", count: string | number]

    Returns Promise<null | [key: string, members: string[]]>

  • Parameters

    • Rest...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], left: "LEFT", countToken: "COUNT", count: string | number]

    Returns Promise<null | [key: string, members: string[]]>

  • Parameters

    • Rest...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], right: "RIGHT", callback: Callback<null | [key: string, members: string[]]>]

    Returns Promise<null | [key: string, members: string[]]>

  • Parameters

    • Rest...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], right: "RIGHT", callback: Callback<null | [key: string, members: string[]]>]

    Returns Promise<null | [key: string, members: string[]]>

  • Parameters

    • Rest...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], right: "RIGHT"]

    Returns Promise<null | [key: string, members: string[]]>

  • Parameters

    • Rest...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], right: "RIGHT"]

    Returns Promise<null | [key: string, members: string[]]>

  • Parameters

    • Rest...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], right: "RIGHT", countToken: "COUNT", count: string | number, callback: Callback<null | [key: string, members: string[]]>]

    Returns Promise<null | [key: string, members: string[]]>

  • Parameters

    • Rest...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], right: "RIGHT", countToken: "COUNT", count: string | number, callback: Callback<null | [key: string, members: string[]]>]

    Returns Promise<null | [key: string, members: string[]]>

  • Parameters

    • Rest...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], right: "RIGHT", countToken: "COUNT", count: string | number]

    Returns Promise<null | [key: string, members: string[]]>

  • Parameters

    • Rest...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], right: "RIGHT", countToken: "COUNT", count: string | number]

    Returns Promise<null | [key: string, members: string[]]>

  • Parameters

    • Rest...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], left: "LEFT", callback: Callback<null | [key: Buffer, members: Buffer[]]>]

    Returns Promise<null | [key: Buffer, members: Buffer[]]>

  • Parameters

    • Rest...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], left: "LEFT", callback: Callback<null | [key: Buffer, members: Buffer[]]>]

    Returns Promise<null | [key: Buffer, members: Buffer[]]>

  • Parameters

    • Rest...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], left: "LEFT"]

    Returns Promise<null | [key: Buffer, members: Buffer[]]>

  • Parameters

    • Rest...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], left: "LEFT"]

    Returns Promise<null | [key: Buffer, members: Buffer[]]>

  • Parameters

    • Rest...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], left: "LEFT", countToken: "COUNT", count: string | number, callback: Callback<null | [key: Buffer, members: Buffer[]]>]

    Returns Promise<null | [key: Buffer, members: Buffer[]]>

  • Parameters

    • Rest...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], left: "LEFT", countToken: "COUNT", count: string | number, callback: Callback<null | [key: Buffer, members: Buffer[]]>]

    Returns Promise<null | [key: Buffer, members: Buffer[]]>

  • Parameters

    • Rest...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], left: "LEFT", countToken: "COUNT", count: string | number]

    Returns Promise<null | [key: Buffer, members: Buffer[]]>

  • Parameters

    • Rest...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], left: "LEFT", countToken: "COUNT", count: string | number]

    Returns Promise<null | [key: Buffer, members: Buffer[]]>

  • Parameters

    • Rest...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], right: "RIGHT", callback: Callback<null | [key: Buffer, members: Buffer[]]>]

    Returns Promise<null | [key: Buffer, members: Buffer[]]>

  • Parameters

    • Rest...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], right: "RIGHT", callback: Callback<null | [key: Buffer, members: Buffer[]]>]

    Returns Promise<null | [key: Buffer, members: Buffer[]]>

  • Parameters

    • Rest...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], right: "RIGHT"]

    Returns Promise<null | [key: Buffer, members: Buffer[]]>

  • Parameters

    • Rest...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], right: "RIGHT"]

    Returns Promise<null | [key: Buffer, members: Buffer[]]>

  • Parameters

    • Rest...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], right: "RIGHT", countToken: "COUNT", count: string | number, callback: Callback<null | [key: Buffer, members: Buffer[]]>]

    Returns Promise<null | [key: Buffer, members: Buffer[]]>

  • Parameters

    • Rest...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], right: "RIGHT", countToken: "COUNT", count: string | number, callback: Callback<null | [key: Buffer, members: Buffer[]]>]

    Returns Promise<null | [key: Buffer, members: Buffer[]]>

  • Parameters

    • Rest...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], right: "RIGHT", countToken: "COUNT", count: string | number]

    Returns Promise<null | [key: Buffer, members: Buffer[]]>

  • Parameters

    • Rest...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], right: "RIGHT", countToken: "COUNT", count: string | number]

    Returns Promise<null | [key: Buffer, members: Buffer[]]>

  • Remove and get the first element in a list, or block until one is available

    • group: list
    • complexity: O(N) where N is the number of provided keys.
    • since: 2.0.0

    Parameters

    • Rest...args: [...keys: RedisKey[], timeout: string | number, callback: Callback<null | [string, string]>]

    Returns Promise<null | [string, string]>

  • Parameters

    • Rest...args: [keys: RedisKey[], timeout: string | number, callback: Callback<null | [string, string]>]

    Returns Promise<null | [string, string]>

  • Parameters

    • Rest...args: [...keys: RedisKey[], timeout: string | number]

    Returns Promise<null | [string, string]>

  • Parameters

    • Rest...args: [keys: RedisKey[], timeout: string | number]

    Returns Promise<null | [string, string]>

  • Parameters

    • Rest...args: [...keys: RedisKey[], timeout: string | number, callback: Callback<null | [Buffer, Buffer]>]

    Returns Promise<null | [Buffer, Buffer]>

  • Parameters

    • Rest...args: [keys: RedisKey[], timeout: string | number, callback: Callback<null | [Buffer, Buffer]>]

    Returns Promise<null | [Buffer, Buffer]>

  • Parameters

    • Rest...args: [...keys: RedisKey[], timeout: string | number]

    Returns Promise<null | [Buffer, Buffer]>

  • Parameters

    • Rest...args: [keys: RedisKey[], timeout: string | number]

    Returns Promise<null | [Buffer, Buffer]>

  • Remove and get the last element in a list, or block until one is available

    • group: list
    • complexity: O(N) where N is the number of provided keys.
    • since: 2.0.0

    Parameters

    • Rest...args: [...keys: RedisKey[], timeout: string | number, callback: Callback<null | [string, string]>]

    Returns Promise<null | [string, string]>

  • Parameters

    • Rest...args: [keys: RedisKey[], timeout: string | number, callback: Callback<null | [string, string]>]

    Returns Promise<null | [string, string]>

  • Parameters

    • Rest...args: [...keys: RedisKey[], timeout: string | number]

    Returns Promise<null | [string, string]>

  • Parameters

    • Rest...args: [keys: RedisKey[], timeout: string | number]

    Returns Promise<null | [string, string]>

  • Parameters

    • Rest...args: [...keys: RedisKey[], timeout: string | number, callback: Callback<null | [Buffer, Buffer]>]

    Returns Promise<null | [Buffer, Buffer]>

  • Parameters

    • Rest...args: [keys: RedisKey[], timeout: string | number, callback: Callback<null | [Buffer, Buffer]>]

    Returns Promise<null | [Buffer, Buffer]>

  • Parameters

    • Rest...args: [...keys: RedisKey[], timeout: string | number]

    Returns Promise<null | [Buffer, Buffer]>

  • Parameters

    • Rest...args: [keys: RedisKey[], timeout: string | number]

    Returns Promise<null | [Buffer, Buffer]>

  • Pop an element from a list, push it to another list and return it; or block until one is available

    • group: list
    • complexity: O(1)
    • since: 2.2.0

    Parameters

    • source: RedisKey
    • destination: RedisKey
    • timeout: string | number
    • Optionalcallback: Callback<null | string>

    Returns Promise<null | string>

  • Parameters

    • source: RedisKey
    • destination: RedisKey
    • timeout: string | number
    • Optionalcallback: Callback<null | Buffer>

    Returns Promise<null | Buffer>

  • Remove and return members with scores in a sorted set or block until one is available

    • group: sorted-set
    • complexity: O(K) + O(N*log(M)) where K is the number of provided keys, N being the number of elements in the sorted set, and M being the number of elements popped.
    • since: 7.0.0

    Parameters

    • Rest...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], min: "MIN", callback: Callback<unknown>]

    Returns Promise<unknown>

  • Parameters

    • Rest...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], min: "MIN", callback: Callback<unknown>]

    Returns Promise<unknown>

  • Parameters

    • Rest...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], min: "MIN"]

    Returns Promise<unknown>

  • Parameters

    • Rest...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], min: "MIN"]

    Returns Promise<unknown>

  • Parameters

    • Rest...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], min: "MIN", countToken: "COUNT", count: string | number, callback: Callback<unknown>]

    Returns Promise<unknown>

  • Parameters

    • Rest...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], min: "MIN", countToken: "COUNT", count: string | number, callback: Callback<unknown>]

    Returns Promise<unknown>

  • Parameters

    • Rest...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], min: "MIN", countToken: "COUNT", count: string | number]

    Returns Promise<unknown>

  • Parameters

    • Rest...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], min: "MIN", countToken: "COUNT", count: string | number]

    Returns Promise<unknown>

  • Parameters

    • Rest...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], max: "MAX", callback: Callback<unknown>]

    Returns Promise<unknown>

  • Parameters

    • Rest...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], max: "MAX", callback: Callback<unknown>]

    Returns Promise<unknown>

  • Parameters

    • Rest...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], max: "MAX"]

    Returns Promise<unknown>

  • Parameters

    • Rest...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], max: "MAX"]

    Returns Promise<unknown>

  • Parameters

    • Rest...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], max: "MAX", countToken: "COUNT", count: string | number, callback: Callback<unknown>]

    Returns Promise<unknown>

  • Parameters

    • Rest...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], max: "MAX", countToken: "COUNT", count: string | number, callback: Callback<unknown>]

    Returns Promise<unknown>

  • Parameters

    • Rest...args: [timeout: string | number, numkeys: string | number, ...keys: RedisKey[], max: "MAX", countToken: "COUNT", count: string | number]

    Returns Promise<unknown>

  • Parameters

    • Rest...args: [timeout: string | number, numkeys: string | number, keys: RedisKey[], max: "MAX", countToken: "COUNT", count: string | number]

    Returns Promise<unknown>

  • Remove and return the member with the highest score from one or more sorted sets, or block until one is available

    • group: sorted-set
    • complexity: O(log(N)) with N being the number of elements in the sorted set.
    • since: 5.0.0

    Parameters

    • Rest...args: [...keys: RedisKey[], timeout: string | number, callback: Callback<null | [key: string, member: string, score: string]>]

    Returns Promise<null | [key: string, member: string, score: string]>

  • Parameters

    • Rest...args: [keys: RedisKey[], timeout: string | number, callback: Callback<null | [key: string, member: string, score: string]>]

    Returns Promise<null | [key: string, member: string, score: string]>

  • Parameters

    • Rest...args: [...keys: RedisKey[], timeout: string | number]

    Returns Promise<null | [key: string, member: string, score: string]>

  • Parameters

    • Rest...args: [keys: RedisKey[], timeout: string | number]

    Returns Promise<null | [key: string, member: string, score: string]>

  • Parameters

    • Rest...args: [...keys: RedisKey[], timeout: string | number, callback: Callback<null | [key: Buffer, member: Buffer, score: Buffer]>]

    Returns Promise<null | [key: Buffer, member: Buffer, score: Buffer]>

  • Parameters

    • Rest...args: [keys: RedisKey[], timeout: string | number, callback: Callback<null | [key: Buffer, member: Buffer, score: Buffer]>]

    Returns Promise<null | [key: Buffer, member: Buffer, score: Buffer]>

  • Parameters

    • Rest...args: [...keys: RedisKey[], timeout: string | number]

    Returns Promise<null | [key: Buffer, member: Buffer, score: Buffer]>

  • Parameters

    • Rest...args: [keys: RedisKey[], timeout: string | number]

    Returns Promise<null | [key: Buffer, member: Buffer, score: Buffer]>

  • Remove and return the member with the lowest score from one or more sorted sets, or block until one is available

    • group: sorted-set
    • complexity: O(log(N)) with N being the number of elements in the sorted set.
    • since: 5.0.0

    Parameters

    • Rest...args: [...keys: RedisKey[], timeout: string | number, callback: Callback<null | [key: string, member: string, score: string]>]

    Returns Promise<null | [key: string, member: string, score: string]>

  • Parameters

    • Rest...args: [keys: RedisKey[], timeout: string | number, callback: Callback<null | [key: string, member: string, score: string]>]

    Returns Promise<null | [key: string, member: string, score: string]>

  • Parameters

    • Rest...args: [...keys: RedisKey[], timeout: string | number]

    Returns Promise<null | [key: string, member: string, score: string]>

  • Parameters

    • Rest...args: [keys: RedisKey[], timeout: string | number]

    Returns Promise<null | [key: string, member: string, score: string]>

  • Parameters

    • Rest...args: [...keys: RedisKey[], timeout: string | number, callback: Callback<null | [key: Buffer, member: Buffer, score: Buffer]>]

    Returns Promise<null | [key: Buffer, member: Buffer, score: Buffer]>

  • Parameters

    • Rest...args: [keys: RedisKey[], timeout: string | number, callback: Callback<null | [key: Buffer, member: Buffer, score: Buffer]>]

    Returns Promise<null | [key: Buffer, member: Buffer, score: Buffer]>

  • Parameters

    • Rest...args: [...keys: RedisKey[], timeout: string | number]

    Returns Promise<null | [key: Buffer, member: Buffer, score: Buffer]>

  • Parameters

    • Rest...args: [keys: RedisKey[], timeout: string | number]

    Returns Promise<null | [key: Buffer, member: Buffer, score: Buffer]>

  • Call arbitrary commands.

    redis.call('set', 'foo', 'bar') is the same as redis.set('foo', 'bar'), so the only case you need to use this method is when the command is not supported by ioredis.

    redis.call('set', 'foo', 'bar');
    redis.call('get', 'foo', (err, value) => {
    // value === 'bar'
    });

    Parameters

    • command: string
    • Optionalcallback: Callback<unknown>

    Returns Promise<unknown>

  • Parameters

    • command: string
    • args: (string | number | Buffer)[]
    • Optionalcallback: Callback<unknown>

    Returns Promise<unknown>

  • Parameters

    • Rest...args: [command: string, ...args: (string | number | Buffer)[], callback: Callback<unknown>]

    Returns Promise<unknown>

  • Parameters

    • Rest...args: [command: string, ...args: (string | number | Buffer)[]]

    Returns Promise<unknown>

  • Parameters

    • command: string
    • Optionalcallback: Callback<unknown>

    Returns Promise<unknown>

  • Parameters

    • command: string
    • args: (string | number | Buffer)[]
    • Optionalcallback: Callback<unknown>

    Returns Promise<unknown>

  • Parameters

    • Rest...args: [command: string, ...args: (string | number | Buffer)[], callback: Callback<unknown>]

    Returns Promise<unknown>

  • Parameters

    • Rest...args: [command: string, ...args: (string | number | Buffer)[]]

    Returns Promise<unknown>

  • Instruct the server about tracking or not keys in the next request

    • group: connection
    • complexity: O(1)
    • since: 6.0.0

    Parameters

    • subcommand: "CACHING"
    • yes: "YES"
    • Optionalcallback: Callback<"OK">

    Returns Promise<"OK">

  • Parameters

    • subcommand: "CACHING"
    • no: "NO"
    • Optionalcallback: Callback<"OK">

    Returns Promise<"OK">

  • Get the current connection name

    • group: connection
    • complexity: O(1)
    • since: 2.6.9

    Parameters

    • subcommand: "GETNAME"
    • Optionalcallback: Callback<null | string>

    Returns Promise<null | string>

  • Get tracking notifications redirection client ID if any

    • group: connection
    • complexity: O(1)
    • since: 6.0.0

    Parameters

    • subcommand: "GETREDIR"
    • Optionalcallback: Callback<number>

    Returns Promise<number>

  • Show helpful text about the different subcommands

    • group: connection
    • complexity: O(1)
    • since: 5.0.0

    Parameters

    • subcommand: "HELP"
    • Optionalcallback: Callback<unknown>

    Returns Promise<unknown>

  • Returns the client ID for the current connection

    • group: connection
    • complexity: O(1)
    • since: 5.0.0

    Parameters

    • subcommand: "ID"
    • Optionalcallback: Callback<number>

    Returns Promise<number>

  • Returns information about the current client connection.

    • group: connection
    • complexity: O(1)
    • since: 6.2.0

    Parameters

    • subcommand: "INFO"
    • Optionalcallback: Callback<string>

    Returns Promise<string>

  • Kill the connection of a client

    • group: connection
    • complexity: O(N) where N is the number of client connections
    • since: 2.4.0

    Parameters

    • Rest...args: [subcommand: "KILL", ...args: RedisValue[], callback: Callback<unknown>]

    Returns Promise<unknown>

  • Parameters

    • Rest...args: [subcommand: "KILL", ...args: RedisValue[]]

    Returns Promise<unknown>

  • Get the list of client connections

    • group: connection
    • complexity: O(N) where N is the number of client connections
    • since: 2.4.0

    Parameters

    • subcommand: "LIST"
    • Optionalcallback: Callback<unknown>

    Returns Promise<unknown>

  • Parameters

    • Rest...args: [subcommand: "LIST", idToken: "ID", ...clientIds: (string | number)[], callback: Callback<unknown>]

    Returns Promise<unknown>

  • Parameters

    • Rest...args: [subcommand: "LIST", idToken: "ID", ...clientIds: (string | number)[]]

    Returns Promise<unknown>

  • Parameters

    • subcommand: "LIST"
    • type: "TYPE"
    • normal: "NORMAL"
    • Optionalcallback: Callback<unknown>

    Returns Promise<unknown>

  • Parameters

    • Rest...args: [subcommand: "LIST", type: "TYPE", normal: "NORMAL", idToken: "ID", ...clientIds: (string | number)[], callback: Callback<unknown>]

    Returns Promise<unknown>

  • Parameters

    • Rest...args: [subcommand: "LIST", type: "TYPE", normal: "NORMAL", idToken: "ID", ...clientIds: (string | number)[]]

    Returns Promise<unknown>

  • Parameters

    • subcommand: "LIST"
    • type: "TYPE"
    • master: "MASTER"
    • Optionalcallback: Callback<unknown>

    Returns Promise<unknown>

  • Parameters

    • Rest...args: [subcommand: "LIST", type: "TYPE", master: "MASTER", idToken: "ID", ...clientIds: (string | number)[], callback: Callback<unknown>]

    Returns Promise<unknown>

  • Parameters

    • Rest...args: [subcommand: "LIST", type: "TYPE", master: "MASTER", idToken: "ID", ...clientIds: (string | number)[]]

    Returns Promise<unknown>

  • Parameters

    • subcommand: "LIST"
    • type: "TYPE"
    • replica: "REPLICA"
    • Optionalcallback: Callback<unknown>

    Returns Promise<unknown>

  • Parameters

    • Rest...args: [subcommand: "LIST", type: "TYPE", replica: "REPLICA", idToken: "ID", ...clientIds: (string | number)[], callback: Callback<unknown>]

    Returns Promise<unknown>

  • Parameters

    • Rest...args: [subcommand: "LIST", type: "TYPE", replica: "REPLICA", idToken: "ID", ...clientIds: (string | number)[]]

    Returns Promise<unknown>

  • Parameters

    • subcommand: "LIST"
    • type: "TYPE"
    • pubsub: "PUBSUB"
    • Optionalcallback: Callback<unknown>

    Returns Promise<unknown>

  • Parameters

    • Rest...args: [subcommand: "LIST", type: "TYPE", pubsub: "PUBSUB", idToken: "ID", ...clientIds: (string | number)[], callback: Callback<unknown>]

    Returns Promise<unknown>

  • Parameters

    • Rest...args: [subcommand: "LIST", type: "TYPE", pubsub: "PUBSUB", idToken: "ID", ...clientIds: (string | number)[]]

    Returns Promise<unknown>

  • Set client eviction mode for the current connection

    • group: connection
    • complexity: O(1)
    • since: 7.0.0

    Parameters

    • subcommand: "NO-EVICT"
    • on: "ON"
    • Optionalcallback: Callback<unknown>

    Returns Promise<unknown>

  • Parameters

    • subcommand: "NO-EVICT"
    • off: "OFF"
    • Optionalcallback: Callback<unknown>

    Returns Promise<unknown>

  • Stop processing commands from clients for some time

    • group: connection
    • complexity: O(1)
    • since: 2.9.50

    Parameters

    • subcommand: "PAUSE"
    • timeout: string | number
    • Optionalcallback: Callback<"OK">

    Returns Promise<"OK">

  • Parameters

    • subcommand: "PAUSE"
    • timeout: string | number
    • write: "WRITE"
    • Optionalcallback: Callback<"OK">

    Returns Promise<"OK">

  • Parameters

    • subcommand: "PAUSE"
    • timeout: string | number
    • all: "ALL"
    • Optionalcallback: Callback<"OK">

    Returns Promise<"OK">

  • Instruct the server whether to reply to commands

    • group: connection
    • complexity: O(1)
    • since: 3.2.0

    Parameters

    • subcommand: "REPLY"
    • on: "ON"
    • Optionalcallback: Callback<unknown>

    Returns Promise<unknown>

  • Parameters

    • subcommand: "REPLY"
    • off: "OFF"
    • Optionalcallback: Callback<unknown>

    Returns Promise<unknown>

  • Parameters

    • subcommand: "REPLY"
    • skip: "SKIP"
    • Optionalcallback: Callback<unknown>

    Returns Promise<unknown>

  • Set the current connection name

    • group: connection
    • complexity: O(1)
    • since: 2.6.9

    Parameters

    • subcommand: "SETNAME"
    • connectionName: string | Buffer
    • Optionalcallback: Callback<"OK">

    Returns Promise<"OK">

  • Enable or disable server assisted client side caching support

    • group: connection
    • complexity: O(1). Some options may introduce additional complexity.
    • since: 6.0.0

    Parameters

    • Rest...args: [subcommand: "TRACKING", ...args: RedisValue[], callback: Callback<unknown>]

    Returns Promise<unknown>

  • Parameters

    • Rest...args: [subcommand: "TRACKING", ...args: RedisValue[]]

    Returns Promise<unknown>

  • Return information about server assisted client side caching for the current connection

    • group: connection
    • complexity: O(1)
    • since: 6.2.0

    Parameters

    • subcommand: "TRACKINGINFO"
    • Optionalcallback: Callback<string>

    Returns Promise<string>

  • Unblock a client blocked in a blocking command from a different connection

    • group: connection
    • complexity: O(log N) where N is the number of client connections
    • since: 5.0.0

    Parameters

    • subcommand: "UNBLOCK"
    • clientId: string | number
    • Optionalcallback: Callback<unknown>

    Returns Promise<unknown>

  • Parameters

    • subcommand: "UNBLOCK"
    • clientId: string | number
    • timeout: "TIMEOUT"
    • Optionalcallback: Callback<unknown>

    Returns Promise<unknown>

  • Parameters

    • subcommand: "UNBLOCK"
    • clientId: string | number
    • error: "ERROR"
    • Optionalcallback: Callback<unknown>

    Returns Promise<unknown>

  • Resume processing of clients that were paused

    • group: connection
    • complexity: O(N) Where N is the number of paused clients
    • since: 6.2.0

    Parameters

    • subcommand: "UNPAUSE"
    • Optionalcallback: Callback<"OK">

    Returns Promise<"OK">

  • Parameters

    • subcommand: "GETNAME"
    • Optionalcallback: Callback<null | Buffer>

    Returns Promise<null | Buffer>

  • Parameters

    • subcommand: "INFO"
    • Optionalcallback: Callback<Buffer>

    Returns Promise<Buffer>

  • Parameters

    • subcommand: "TRACKINGINFO"
    • Optionalcallback: Callback<Buffer>

    Returns Promise<Buffer>

  • Assign new hash slots to receiving node

    • group: cluster
    • complexity: O(N) where N is the total number of hash slot arguments
    • since: 3.0.0

    Parameters

    • Rest...args: [subcommand: "ADDSLOTS", ...slots: (string | number)[], callback: Callback<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>]

    Returns Promise<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>

  • Parameters

    • Rest...args: [subcommand: "ADDSLOTS", slots: (string | number)[], callback: Callback<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>]

    Returns Promise<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>

  • Parameters

    • Rest...args: [subcommand: "ADDSLOTS", ...slots: (string | number)[]]

    Returns Promise<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>

  • Parameters

    • Rest...args: [subcommand: "ADDSLOTS", slots: (string | number)[]]

    Returns Promise<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>

  • Assign new hash slots to receiving node

    • group: cluster
    • complexity: O(N) where N is the total number of the slots between the start slot and end slot arguments.
    • since: 7.0.0

    Parameters

    • Rest...args: [subcommand: "ADDSLOTSRANGE", ...startSlotEndSlots: (string | number)[], callback: Callback<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>]

    Returns Promise<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>

  • Parameters

    • Rest...args: [subcommand: "ADDSLOTSRANGE", ...startSlotEndSlots: (string | number)[]]

    Returns Promise<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>

  • Advance the cluster config epoch

    • group: cluster
    • complexity: O(1)
    • since: 3.0.0

    Parameters

    • subcommand: "BUMPEPOCH"
    • Optionalcallback: Callback<"BUMPED" | "STILL">

    Returns Promise<"BUMPED" | "STILL">

  • Return the number of failure reports active for a given node

    • group: cluster
    • complexity: O(N) where N is the number of failure reports
    • since: 3.0.0

    Parameters

    • subcommand: "COUNT-FAILURE-REPORTS"
    • nodeId: string | number | Buffer
    • Optionalcallback: Callback<number>

    Returns Promise<number>

  • Return the number of local keys in the specified hash slot

    • group: cluster
    • complexity: O(1)
    • since: 3.0.0

    Parameters

    • subcommand: "COUNTKEYSINSLOT"
    • slot: string | number
    • Optionalcallback: Callback<number>

    Returns Promise<number>

  • Set hash slots as unbound in receiving node

    • group: cluster
    • complexity: O(N) where N is the total number of hash slot arguments
    • since: 3.0.0

    Parameters

    • Rest...args: [subcommand: "DELSLOTS", ...slots: (string | number)[], callback: Callback<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>]

    Returns Promise<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>

  • Parameters

    • Rest...args: [subcommand: "DELSLOTS", slots: (string | number)[], callback: Callback<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>]

    Returns Promise<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>

  • Parameters

    • Rest...args: [subcommand: "DELSLOTS", ...slots: (string | number)[]]

    Returns Promise<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>

  • Parameters

    • Rest...args: [subcommand: "DELSLOTS", slots: (string | number)[]]

    Returns Promise<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>

  • Set hash slots as unbound in receiving node

    • group: cluster
    • complexity: O(N) where N is the total number of the slots between the start slot and end slot arguments.
    • since: 7.0.0

    Parameters

    • Rest...args: [subcommand: "DELSLOTSRANGE", ...startSlotEndSlots: (string | number)[], callback: Callback<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>]

    Returns Promise<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>

  • Parameters

    • Rest...args: [subcommand: "DELSLOTSRANGE", ...startSlotEndSlots: (string | number)[]]

    Returns Promise<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>

  • Forces a replica to perform a manual failover of its master.

    • group: cluster
    • complexity: O(1)
    • since: 3.0.0

    Parameters

    • subcommand: "FAILOVER"
    • Optionalcallback: Callback<"OK">

    Returns Promise<"OK">

  • Parameters

    • subcommand: "FAILOVER"
    • force: "FORCE"
    • Optionalcallback: Callback<"OK">

    Returns Promise<"OK">

  • Parameters

    • subcommand: "FAILOVER"
    • takeover: "TAKEOVER"
    • Optionalcallback: Callback<"OK">

    Returns Promise<"OK">

  • Delete a node's own slots information

    • group: cluster
    • complexity: O(1)
    • since: 3.0.0

    Parameters

    • subcommand: "FLUSHSLOTS"
    • Optionalcallback: Callback<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>

    Returns Promise<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>

  • Remove a node from the nodes table

    • group: cluster
    • complexity: O(1)
    • since: 3.0.0

    Parameters

    • subcommand: "FORGET"
    • nodeId: string | number | Buffer
    • Optionalcallback: Callback<"OK">

    Returns Promise<"OK">

  • Return local key names in the specified hash slot

    • group: cluster
    • complexity: O(log(N)) where N is the number of requested keys
    • since: 3.0.0

    Parameters

    • subcommand: "GETKEYSINSLOT"
    • slot: string | number
    • count: string | number
    • Optionalcallback: Callback<string[]>

    Returns Promise<string[]>

  • Show helpful text about the different subcommands

    • group: cluster
    • complexity: O(1)
    • since: 5.0.0

    Parameters

    • subcommand: "HELP"
    • Optionalcallback: Callback<unknown>

    Returns Promise<unknown>

  • Provides info about Redis Cluster node state

    • group: cluster
    • complexity: O(1)
    • since: 3.0.0

    Parameters

    • subcommand: "INFO"
    • Optionalcallback: Callback<string>

    Returns Promise<string>

  • Returns the hash slot of the specified key

    • group: cluster
    • complexity: O(N) where N is the number of bytes in the key
    • since: 3.0.0

    Parameters

    • subcommand: "KEYSLOT"
    • key: string | Buffer
    • Optionalcallback: Callback<number>

    Returns Promise<number>

  • Returns a list of all TCP links to and from peer nodes in cluster

    • group: cluster
    • complexity: O(N) where N is the total number of Cluster nodes
    • since: 7.0.0

    Parameters

    • subcommand: "LINKS"
    • Optionalcallback: Callback<unknown[]>

    Returns Promise<unknown[]>

  • Force a node cluster to handshake with another node

    • group: cluster
    • complexity: O(1)
    • since: 3.0.0

    Parameters

    • subcommand: "MEET"
    • ip: string | Buffer
    • port: string | number
    • Optionalcallback: Callback<"OK">

    Returns Promise<"OK">

  • Return the node id

    • group: cluster
    • complexity: O(1)
    • since: 3.0.0

    Parameters

    • subcommand: "MYID"
    • Optionalcallback: Callback<string>

    Returns Promise<string>

  • Get Cluster config for the node

    • group: cluster
    • complexity: O(N) where N is the total number of Cluster nodes
    • since: 3.0.0

    Parameters

    • subcommand: "NODES"
    • Optionalcallback: Callback<unknown>

    Returns Promise<unknown>

  • List replica nodes of the specified master node

    • group: cluster
    • complexity: O(1)
    • since: 5.0.0

    Parameters

    • subcommand: "REPLICAS"
    • nodeId: string | number | Buffer
    • Optionalcallback: Callback<unknown>

    Returns Promise<unknown>

  • Reconfigure a node as a replica of the specified master node

    • group: cluster
    • complexity: O(1)
    • since: 3.0.0

    Parameters

    • subcommand: "REPLICATE"
    • nodeId: string | number | Buffer
    • Optionalcallback: Callback<"OK">

    Returns Promise<"OK">

  • Reset a Redis Cluster node

    • group: cluster
    • complexity: O(N) where N is the number of known nodes. The command may execute a FLUSHALL as a side effect.
    • since: 3.0.0

    Parameters

    • subcommand: "RESET"
    • Optionalcallback: Callback<"OK">

    Returns Promise<"OK">

  • Parameters

    • subcommand: "RESET"
    • hard: "HARD"
    • Optionalcallback: Callback<"OK">

    Returns Promise<"OK">

  • Parameters

    • subcommand: "RESET"
    • soft: "SOFT"
    • Optionalcallback: Callback<"OK">

    Returns Promise<"OK">

  • Forces the node to save cluster state on disk

    • group: cluster
    • complexity: O(1)
    • since: 3.0.0

    Parameters

    • subcommand: "SAVECONFIG"
    • Optionalcallback: Callback<"OK">

    Returns Promise<"OK">

  • Set the configuration epoch in a new node

    • group: cluster
    • complexity: O(1)
    • since: 3.0.0

    Parameters

    • subcommand: "SET-CONFIG-EPOCH"
    • configEpoch: string | number
    • Optionalcallback: Callback<"OK">

    Returns Promise<"OK">

  • Bind a hash slot to a specific node

    • group: cluster
    • complexity: O(1)
    • since: 3.0.0

    Parameters

    • subcommand: "SETSLOT"
    • slot: string | number
    • nodeIdToken: "IMPORTING"
    • nodeId: string | number | Buffer
    • Optionalcallback: Callback<"OK">

    Returns Promise<"OK">

  • Parameters

    • subcommand: "SETSLOT"
    • slot: string | number
    • nodeIdToken: "MIGRATING"
    • nodeId: string | number | Buffer
    • Optionalcallback: Callback<"OK">

    Returns Promise<"OK">

  • Parameters

    • subcommand: "SETSLOT"
    • slot: string | number
    • nodeIdToken: "NODE"
    • nodeId: string | number | Buffer
    • Optionalcallback: Callback<"OK">

    Returns Promise<"OK">

  • Parameters

    • subcommand: "SETSLOT"
    • slot: string | number
    • stable: "STABLE"
    • Optionalcallback: Callback<"OK">

    Returns Promise<"OK">

  • Get array of cluster slots to node mappings

    • group: cluster
    • complexity: O(N) where N is the total number of cluster nodes
    • since: 7.0.0

    Parameters

    • subcommand: "SHARDS"
    • Optionalcallback: Callback<unknown>

    Returns Promise<unknown>

  • List replica nodes of the specified master node

    • group: cluster
    • complexity: O(1)
    • since: 3.0.0

    Parameters

    • subcommand: "SLAVES"
    • nodeId: string | number | Buffer
    • Optionalcallback: Callback<unknown>

    Returns Promise<unknown>

  • Get array of Cluster slot to node mappings

    • group: cluster
    • complexity: O(N) where N is the total number of Cluster nodes
    • since: 3.0.0

    Parameters

    • subcommand: "SLOTS"
    • Optionalcallback: Callback<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>

    Returns Promise<[startSlotRange: number, endSlotRange: number, ...nodes: [host: string, port: number, nodeId: string, info: unknown[]][]][]>

  • Get total number of Redis commands

    • group: server
    • complexity: O(1)
    • since: 2.8.13

    Parameters

    • subcommand: "COUNT"
    • Optionalcallback: Callback<unknown[]>

    Returns Promise<unknown[]>

  • Get array of specific Redis command documentation

    • group: server
    • complexity: O(N) where N is the number of commands to look up
    • since: 7.0.0

    Parameters

    • subcommand: "DOCS"
    • Optionalcallback: Callback<unknown[]>

    Returns Promise<unknown[]>

  • Parameters

    • Rest...args: [subcommand: "DOCS", ...commandNames: (string | Buffer)[], callback: Callback<unknown[]>]

    Returns Promise<unknown[]>

  • Parameters

    • Rest...args: [subcommand: "DOCS", ...commandNames: (string | Buffer)[]]

    Returns Promise<unknown[]>

  • Extract keys given a full Redis command

    • group: server
    • complexity: O(N) where N is the number of arguments to the command
    • since: 2.8.13

    Parameters

    • subcommand: "GETKEYS"
    • Optionalcallback: Callback<unknown[]>

    Returns Promise<unknown[]>

  • Extract keys and access flags given a full Redis command

    • group: server
    • complexity: O(N) where N is the number of arguments to the command
    • since: 7.0.0

    Parameters

    • subcommand: "GETKEYSANDFLAGS"
    • Optionalcallback: Callback<unknown[]>

    Returns Promise<unknown[]>

  • Show helpful text about the different subcommands

    • group: server
    • complexity: O(1)
    • since: 5.0.0

    Parameters

    • subcommand: "HELP"
    • Optionalcallback: Callback<unknown[]>

    Returns Promise<unknown[]>

  • Get array of specific Redis command details, or all when no argument is given.

    • group: server
    • complexity: O(N) where N is the number of commands to look up
    • since: 2.8.13

    Parameters

    • subcommand: "INFO"
    • Optionalcallback: Callback<unknown[]>

    Returns Promise<unknown[]>

  • Parameters

    • Rest...args: [subcommand: "INFO", ...commandNames: (string | Buffer)[], callback: Callback<unknown[]>]

    Returns Promise<unknown[]>

  • Parameters

    • Rest...args: [subcommand: "INFO", ...commandNames: (string | Buffer)[]]

    Returns Promise<unknown[]>

  • Get an array of Redis command names

    • group: server
    • complexity: O(N) where N is the total number of Redis commands
    • since: 7.0.0

    Parameters

    • subcommand: "LIST"
    • Optionalcallback: Callback<unknown[]>

    Returns Promise<unknown[]>

  • Parameters

    • subcommand: "LIST"
    • filterby: "FILTERBY"
    • moduleNameToken: "MODULE"
    • moduleName: string | Buffer
    • Optionalcallback: Callback<unknown[]>

    Returns Promise<unknown[]>

  • Parameters

    • subcommand: "LIST"
    • filterby: "FILTERBY"
    • categoryToken: "ACLCAT"
    • category: string | Buffer
    • Optionalcallback: Callback<unknown[]>

    Returns Promise<unknown[]>

  • Parameters

    • subcommand: "LIST"
    • filterby: "FILTERBY"
    • patternToken: "PATTERN"
    • pattern: string
    • Optionalcallback: Callback<unknown[]>

    Returns Promise<unknown[]>

  • Get the values of configuration parameters

    • group: server
    • complexity: O(N) when N is the number of configuration parameters provided
    • since: 2.0.0

    Parameters

    • Rest...args: [subcommand: "GET", ...parameters: (string | Buffer)[], callback: Callback<unknown>]

    Returns Promise<unknown>

  • Parameters

    • Rest...args: [subcommand: "GET", ...parameters: (string | Buffer)[]]

    Returns Promise<unknown>

  • Show helpful text about the different subcommands

    • group: server
    • complexity: O(1)
    • since: 5.0.0

    Parameters

    • subcommand: "HELP"
    • Optionalcallback: Callback<unknown>

    Returns Promise<unknown>

  • Reset the stats returned by INFO

    • group: server
    • complexity: O(1)
    • since: 2.0.0

    Parameters

    • subcommand: "RESETSTAT"
    • Optionalcallback: Callback<unknown>

    Returns Promise<unknown>

  • Rewrite the configuration file with the in memory configuration

    • group: server
    • complexity: O(1)
    • since: 2.8.0

    Parameters

    • subcommand: "REWRITE"
    • Optionalcallback: Callback<unknown>

    Returns Promise<unknown>

  • Set configuration parameters to the given values

    • group: server
    • complexity: O(N) when N is the number of configuration parameters provided
    • since: 2.0.0

    Parameters

    • Rest...args: [subcommand: "SET", ...parameterValues: (string | number | Buffer)[], callback: Callback<unknown>]

    Returns Promise<unknown>

  • Parameters

    • Rest...args: [subcommand: "SET", ...parameterValues: (string | number | Buffer)[]]

    Returns Promise<unknown>

  • Create a connection to Redis. This method will be invoked automatically when creating a new Redis instance unless lazyConnect: true is passed.

    When calling this method manually, a Promise is returned, which will be resolved when the connection status is ready.

    Parameters

    • Optionalcallback: Callback<void>

    Returns Promise<void>

  • Copy a key

    • group: generic
    • complexity: O(N) worst case for collections, where N is the number of nested items. O(1) for string values.
    • since: 6.2.0

    Parameters

    • source: RedisKey
    • destination: RedisKey
    • Optionalcallback: Callback<number>

    Returns Promise<number>

  • Parameters

    • source: RedisKey
    • destination: RedisKey
    • replace: "REPLACE"
    • Optionalcallback: Callback<number>

    Returns Promise<number>

  • Parameters

    • source: RedisKey
    • destination: RedisKey
    • destinationDbToken: "DB"
    • destinationDb: string | number
    • Optionalcallback: Callback<number>

    Returns Promise<number>

  • Parameters

    • source: RedisKey
    • destination: RedisKey
    • destinationDbToken: "DB"
    • destinationDb: string | number
    • replace: "REPLACE"
    • Optionalcallback: Callback<number>

    Returns Promise<number>

  • Create a builtin command

    Parameters

    • commandName: string

    Returns {
        buffer: any;
        string: any;
    }

    • buffer: any
    • string: any
  • Return the number of keys in the selected database

    • group: server
    • complexity: O(1)
    • since: 1.0.0

    Parameters

    • Optionalcallback: Callback<number>

    Returns Promise<number>

  • A container for debugging commands

    • group: server
    • complexity: Depends on subcommand.
    • since: 1.0.0

    Parameters

    • subcommand: string
    • Optionalcallback: Callback<unknown>

    Returns Promise<unknown>

  • Parameters

    • Rest...args: [subcommand: string, ...args: (string | number | Buffer)[], callback: Callback<unknown>]

    Returns Promise<unknown>

  • Parameters

    • Rest...args: [subcommand: string, ...args: (string | number | Buffer)[]]

    Returns Promise<unknown>

  • Decrement the integer value of a key by one

    • group: string
    • complexity: O(1)
    • since: 1.0.0

    Parameters

    • key: RedisKey
    • Optionalcallback: Callback<number>

    Returns Promise<number>

  • Decrement the integer value of a key by the given number

    • group: string
    • complexity: O(1)
    • since: 1.0.0

    Parameters

    • key: RedisKey
    • decrement: string | number
    • Optionalcallback: Callback<number>

    Returns Promise<number>

  • Define a custom command using lua script

    Parameters

    • name: string
    • definition: {
          lua: string;
          numberOfKeys?: number;
          readOnly?: boolean;
      }
      • lua: string
      • OptionalnumberOfKeys?: number
      • OptionalreadOnly?: boolean

    Returns void

  • Delete a key

    • group: generic
    • complexity: O(N) where N is the number of keys that will be removed. When a key to remove holds a value other than a string, the individual complexity for this key is O(M) where M is the number of elements in the list, set, sorted set or hash. Removing a single key that holds a string value is O(1).
    • since: 1.0.0

    Parameters

    • Rest...args: [...keys: RedisKey[], callback: Callback<number>]

    Returns Promise<number>

  • Parameters

    • Rest...args: [keys: RedisKey[], callback: Callback<number>]

    Returns Promise<number>

  • Parameters

    • Rest...args: RedisKey[]

    Returns Promise<number>

  • Parameters

    • Rest...args: [keys: RedisKey[]]

    Returns Promise<number>

  • Discard all commands issued after MULTI

    • group: transactions
    • complexity: O(N), when N is the number of queued commands
    • since: 2.0.0

    Parameters

    • Optionalcallback: Callback<"OK">

    Returns Promise<"OK">

  • Disconnect from Redis.

    This method closes the connection immediately, and may lose some pending replies that haven't written to client. If you want to wait for the pending replies, use Redis#quit instead.

    Parameters

    • Optionalreconnect: boolean

    Returns void

  • Return a serialized version of the value stored at the specified key.

    • group: generic
    • complexity: O(1) to access the key and additional O(NM) to serialize it, where N is the number of Redis objects composing the value and M their average size. For small string values the time complexity is thus O(1)+O(1M) where M is small, so simply O(1).
    • since: 2.6.0

    Parameters

    • key: RedisKey
    • Optionalcallback: Callback<string>

    Returns Promise<string>

  • Parameters

    • key: RedisKey
    • Optionalcallback: Callback<Buffer>

    Returns Promise<Buffer>

  • Create a new instance with the same options as the current one.

    Parameters

    Returns Redis

    var redis = new Redis(6380);
    var anotherRedis = redis.duplicate();
  • Echo the given string

    • group: connection
    • complexity: O(1)
    • since: 1.0.0

    Parameters

    • message: string | Buffer
    • Optionalcallback: Callback<string>

    Returns Promise<string>

  • Parameters

    • message: string | Buffer
    • Optionalcallback: Callback<Buffer>

    Returns Promise<Buffer>

  • Synchronously calls each of the listeners registered for the event named eventName, in the order they were registered, passing the supplied arguments to each.

    Returns true if the event had listeners, false otherwise.

    import { EventEmitter } from 'node:events';
    const myEmitter = new EventEmitter();

    // First listener
    myEmitter.on('event', function firstListener() {
    console.log('Helloooo! first listener');
    });
    // Second listener
    myEmitter.on('event', function secondListener(arg1, arg2) {
    console.log(`event with parameters ${arg1}, ${arg2} in second listener`);
    });
    // Third listener
    myEmitter.on('event', function thirdListener(...args) {
    const parameters = args.join(', ');
    console.log(`event with parameters ${parameters} in third listener`);
    });

    console.log(myEmitter.listeners('event'));

    myEmitter.emit('event', 1, 2, 3, 4, 5);

    // Prints:
    // [
    // [Function: firstListener],
    // [Function: secondListener],
    // [Function: thirdListener]
    // ]
    // Helloooo! first listener
    // event with parameters 1, 2 in second listener
    // event with parameters 1, 2, 3, 4, 5 in third listener

    Type Parameters

    • K

    Parameters

    • eventName: string | symbol
    • Rest...args: AnyRest

    Returns boolean

    v0.1.26

  • Disconnect from Redis.

    Returns void

  • Execute a Lua script server side

    • group: scripting
    • complexity: Depends on the script that is executed.
    • since: 2.6.0

    Parameters

    • script: string | Buffer
    • numkeys: string | number
    • Optionalcallback: Callback<unknown>

    Returns Promise<unknown>

  • Parameters

    • Rest...args: [script: string | Buffer, numkeys: string | number, ...args: (string | number | Buffer)[], callback: Callback<unknown>]

    Returns Promise<unknown>

  • Parameters

    • Rest...args: [script: string | Buffer, numkeys: string | number, ...args: (string | number | Buffer)[]]

    Returns Promise<unknown>

  • Parameters

    • Rest...args: [script: string | Buffer, numkeys: string | number, ...keys: RedisKey[], callback: Callback<unknown>]

    Returns Promise<unknown>

  • Parameters

    • Rest...args: [script: string | Buffer, numkeys: string | number, keys: RedisKey[], callback: Callback<unknown>]

    Returns Promise<unknown>

  • Parameters

    • Rest...args: [script: string | Buffer, numkeys: string | number, ...keys: RedisKey[]]

    Returns Promise<unknown>

  • Parameters

    • Rest...args: [script: string | Buffer, numkeys: string | number, keys: RedisKey[]]

    Returns Promise<unknown>

  • Parameters

    • Rest...args: [script: string | Buffer, numkeys: string | number, ...args: RedisValue[], callback: Callback<unknown>]

    Returns Promise<unknown>

  • Parameters

    • Rest...args: [script: string | Buffer, numkeys: string | number, ...args: RedisValue[]]

    Returns Promise<unknown>

  • Execute a read-only Lua script server side

    • group: scripting
    • complexity: Depends on the script that is executed.
    • since: 7.0.0

    Parameters

    • Rest...args: [script: string | Buffer, numkeys: string | number, ...args: RedisValue[], callback: Callback<unknown>]

    Returns Promise<unknown>

  • Parameters

    • Rest...args: [script: string | Buffer, numkeys: string | number, ...args: RedisValue[]]

    Returns Promise<unknown>

  • Execute a Lua script server side

    • group: scripting
    • complexity: Depends on the script that is executed.
    • since: 2.6.0

    Parameters

    • sha1: string | Buffer
    • numkeys: string | number
    • Optionalcallback: Callback<unknown>

    Returns Promise<unknown>

  • Parameters

    • Rest...args: [sha1: string | Buffer, numkeys: string | number, ...args: (string | number | Buffer)[], callback: Callback<unknown>]

    Returns Promise<unknown>

  • Parameters

    • Rest...args: [sha1: string | Buffer, numkeys: string | number, ...args: (string | number | Buffer)[]]

    Returns Promise<unknown>

  • Parameters

    • Rest...args: [sha1: string | Buffer, numkeys: string | number, ...keys: RedisKey[], callback: Callback<unknown>]

    Returns Promise<unknown>

  • Parameters

    • Rest...args: [sha1: string | Buffer, numkeys: string | number, keys: RedisKey[], callback: Callback<unknown>]

    Returns Promise<unknown>

  • Parameters

    • Rest...args: [sha1: string | Buffer, numkeys: string | number, ...keys: RedisKey[]]

    Returns Promise<unknown>

  • Parameters

    • Rest...args: [sha1: string | Buffer, numkeys: string | number, keys: RedisKey[]]

    Returns Promise<unknown>

  • Parameters

    • Rest...args: [sha1: string | Buffer, numkeys: string | number, ...args: RedisValue[], callback: Callback<unknown>]

    Returns Promise<unknown>

  • Parameters

    • Rest...args: [sha1: string | Buffer, numkeys: string | number, ...args: RedisValue[]]

    Returns Promise<unknown>

  • Execute a read-only Lua script server side

    • group: scripting
    • complexity: Depends on the script that is executed.
    • since: 7.0.0

    Parameters

    • Rest...args: [sha1: string | Buffer, numkeys: string | number, ...args: RedisValue[], callback: Callback<unknown>]

    Returns Promise<unknown>

  • Parameters

    • Rest...args: [sha1: string | Buffer, numkeys: string | number, ...args: RedisValue[]]

    Returns Promise<unknown>

  • Returns an array listing the events for which the emitter has registered listeners. The values in the array are strings or Symbols.

    import { EventEmitter } from 'node:events';

    const myEE = new EventEmitter();
    myEE.on('foo', () => {});
    myEE.on('bar', () => {});

    const sym = Symbol('symbol');
    myEE.on(sym, () => {});

    console.log(myEE.eventNames());
    // Prints: [ 'foo', 'bar', Symbol(symbol) ]

    Returns (string | symbol)[]

    v6.0.0

  • Execute all commands issued after MULTI

    • group: transactions
    • complexity: Depends on commands in the transaction
    • since: 1.2.0

    Parameters

    • Optionalcallback: Callback<null | [error: null | Error, result: unknown][]>

    Returns Promise<null | [error: null | Error, result: unknown][]>

  • Determine if a key exists

    • group: generic
    • complexity: O(N) where N is the number of keys to check.
    • since: 1.0.0

    Parameters

    • Rest...args: [...keys: RedisKey[], callback: Callback<number>]

    Returns Promise<number>

  • Parameters

    • Rest...args: [keys: RedisKey[], callback: Callback<number>]

    Returns Promise<number>

  • Parameters

    • Rest...args: RedisKey[]

    Returns Promise<number>

  • Parameters

    • Rest...args: [keys: RedisKey[]]

    Returns Promise<number>

  • Set a key's time to live in seconds

    • group: generic
    • complexity: O(1)
    • since: 1.0.0

    Parameters

    • key: RedisKey
    • seconds: string | number
    • Optionalcallback: Callback<number>

    Returns Promise<number>

  • Parameters

    • key: RedisKey
    • seconds: string | number
    • nx: "NX"
    • Optionalcallback: Callback<number>

    Returns Promise<number>

  • Parameters

    • key: RedisKey
    • seconds: string | number
    • xx: "XX"
    • Optionalcallback: Callback<number>

    Returns Promise<number>

  • Parameters

    • key: RedisKey
    • seconds: string | number
    • gt: "GT"
    • Optionalcallback: Callback<number>

    Returns Promise<number>

  • Parameters

    • key: RedisKey
    • seconds: string | number
    • lt: "LT"
    • Optionalcallback: Callback<number>

    Returns Promise<number>

  • Set the expiration for a key as a UNIX timestamp

    • group: generic
    • complexity: O(1)
    • since: 1.2.0

    Parameters

    • key: RedisKey
    • unixTimeSeconds: string | number
    • Optionalcallback: Callback<number>

    Returns Promise<number>

  • Parameters

    • key: RedisKey
    • unixTimeSeconds: string | number
    • nx: "NX"
    • Optionalcallback: Callback<number>

    Returns Promise<number>

  • Parameters

    • key: RedisKey
    • unixTimeSeconds: string | number
    • xx: "XX"
    • Optionalcallback: Callback<number>

    Returns Promise<number>

  • Parameters

    • key: RedisKey
    • unixTimeSeconds: string | number
    • gt: "GT"
    • Optionalcallback: Callback<number>

    Returns Promise<number>

  • Parameters

    • key: RedisKey
    • unixTimeSeconds: string | number
    • lt: "LT"
    • Optionalcallback: Callback<number>

    Returns Promise<number>

  • Get the expiration Unix timestamp for a key

    • group: generic
    • complexity: O(1)
    • since: 7.0.0

    Parameters

    • key: RedisKey
    • Optionalcallback: Callback<number>

    Returns Promise<number>

  • Start a coordinated failover between this server and one of its replicas.

    • group: server
    • complexity: O(1)
    • since: 6.2.0

    Parameters

    • Optionalcallback: Callback<"OK">

    Returns Promise<"OK">

  • Parameters

    • millisecondsToken: "TIMEOUT"
    • milliseconds: string | number
    • Optionalcallback: Callback<"OK">

    Returns Promise<"OK">

  • Parameters

    • abort: "ABORT"
    • Optionalcallback: Callback<"OK">

    Returns Promise<"OK">

  • Parameters

    • abort: "ABORT"
    • millisecondsToken: "TIMEOUT"
    • milliseconds: string | number
    • Optionalcallback: Callback<"OK">

    Returns Promise<"OK">

  • Parameters

    • targetToken: "TO"
    • host: string | Buffer
    • port: string | number
    • Optionalcallback: Callback<"OK">

    Returns Promise<"OK">

  • Parameters

    • targetToken: "TO"
    • host: string | Buffer
    • port: string | number
    • millisecondsToken: "TIMEOUT"
    • milliseconds: string | number
    • Optionalcallback: Callback<"OK">

    Returns Promise<"OK">

  • Parameters

    • targetToken: "TO"
    • host: string | Buffer
    • port: string | number
    • abort: "ABORT"
    • Optionalcallback: Callback<"OK">

    Returns Promise<"OK">

  • Parameters

    • targetToken: "TO"
    • host: string | Buffer
    • port: string | number
    • abort: "ABORT"
    • millisecondsToken: "TIMEOUT"
    • milliseconds: string | number
    • Optionalcallback: Callback<"OK">

    Returns Promise<"OK">

  • Parameters

    • targetToken: "TO"
    • host: string | Buffer
    • port: string | number
    • force: "FORCE"
    • Optionalcallback: Callback<"OK">

    Returns Promise<"OK">

  • Parameters

    • targetToken: "TO"
    • host: string | Buffer
    • port: string | number
    • force: "FORCE"
    • millisecondsToken: "TIMEOUT"
    • milliseconds: string | number
    • Optionalcallback: Callback<"OK">

    Returns Promise<"OK">

  • Parameters

    • targetToken: "TO"
    • host: string | Buffer
    • port: string | number
    • force: "FORCE"
    • abort: "ABORT"
    • Optionalcallback: Callback<"OK">

    Returns Promise<"OK">

  • Parameters

    • targetToken: "TO"
    • host: string | Buffer
    • port: string | number
    • force: "FORCE"
    • abort: "ABORT"
    • millisecondsToken: "TIMEOUT"
    • milliseconds: string | number
    • Optionalcallback: Callback<"OK">

    Returns Promise<"OK">

  • Invoke a function

    • group: scripting
    • complexity: Depends on the function that is executed.
    • since: 7.0.0

    Parameters

    • Rest...args: [function: string | Buffer, numkeys: string | number, ...args: RedisValue[], callback: Callback<unknown>]

    Returns Promise<unknown>

  • Parameters

    • Rest...args: [function: string | Buffer, numkeys: string | number, ...args: RedisValue[]]

    Returns Promise<unknown>

  • Invoke a read-only function

    • group: scripting
    • complexity: Depends on the function that is executed.
    • since: 7.0.0

    Parameters

    • Rest...args: [function: string | Buffer, numkeys: string | number, ...args: RedisValue[], callback: Callback<unknown>]

    Returns Promise<unknown>

  • Parameters

    • Rest...args: [function: string | Buffer, numkeys: string | number, ...args: RedisValue[]]

    Returns Promise<unknown>

  • Remove all keys from all databases

    • group: server
    • complexity: O(N) where N is the total number of keys in all databases
    • since: 1.0.0

    Parameters

    • Optionalcallback: Callback<"OK">

    Returns Promise<"OK">

  • Parameters

    • async: "ASYNC"
    • Optionalcallback: Callback<"OK">

    Returns Promise<"OK">

  • Parameters

    • sync: "SYNC"
    • Optionalcallback: Callback<"OK">

    Returns Promise<"OK">

  • Remove all keys from the current database

    • group: server
    • complexity: O(N) where N is the number of keys in the selected database
    • since: 1.0.0

    Parameters

    • Optionalcallback: Callback<"OK">

    Returns Promise<"OK">

  • Parameters

    • async: "ASYNC"
    • Optionalcallback: Callback<"OK">

    Returns Promise<"OK">

  • Parameters

    • sync: "SYNC"
    • Optionalcallback: Callback<"OK">

    Returns Promise<"OK">

  • Delete a function by name

    • group: scripting
    • complexity: O(1)
    • since: 7.0.0

    Parameters

    • subcommand: "DELETE"
    • libraryName: string | Buffer
    • Optionalcallback: Callback<string>

    Returns Promise<string>

  • Dump all functions into a serialized binary payload

    • group: scripting
    • complexity: O(N) where N is the number of functions
    • since: 7.0.0

    Parameters

    • subcommand: "DUMP"
    • Optionalcallback: Callback<string>

    Returns Promise<string>

  • Deleting all functions

    • group: scripting
    • complexity: O(N) where N is the number of functions deleted
    • since: 7.0.0

    Parameters

    • subcommand: "FLUSH"
    • Optionalcallback: Callback<string>

    Returns Promise<string>

  • Parameters

    • subcommand: "FLUSH"
    • async: "ASYNC"
    • Optionalcallback: Callback<string>

    Returns Promise<string>

  • Parameters

    • subcommand: "FLUSH"
    • sync: "SYNC"
    • Optionalcallback: Callback<string>

    Returns Promise<string>

  • Show helpful text about the different subcommands

    • group: scripting
    • complexity: O(1)
    • since: 7.0.0

    Parameters

    • subcommand: "HELP"
    • Optionalcallback: Callback<unknown>

    Returns Promise<unknown>

  • Kill the function currently in execution.

    • group: scripting
    • complexity: O(1)
    • since: 7.0.0

    Parameters

    • subcommand: "KILL"
    • Optionalcallback: Callback<string>

    Returns Promise<string>

  • List information about all the functions

    • group: scripting
    • complexity: O(N) where N is the number of functions
    • since: 7.0.0

    Parameters

    • subcommand: "LIST"
    • Optionalcallback: Callback<unknown[]>

    Returns Promise<unknown[]>

  • Parameters

    • subcommand: "LIST"
    • withcode: "WITHCODE"
    • Optionalcallback: Callback<unknown[]>

    Returns Promise<unknown[]>

  • Parameters

    • subcommand: "LIST"
    • libraryNamePatternToken: "LIBRARYNAME"
    • libraryNamePattern: string | Buffer
    • Optionalcallback: Callback<unknown[]>

    Returns Promise<unknown[]>

  • Parameters

    • subcommand: "LIST"
    • libraryNamePatternToken: "LIBRARYNAME"
    • libraryNamePattern: string | Buffer
    • withcode: "WITHCODE"
    • Optionalcallback: Callback<unknown[]>

    Returns Promise<unknown[]>

  • Create a function with the given arguments (name, code, description)

    • group: scripting
    • complexity: O(1) (considering compilation time is redundant)
    • since: 7.0.0

    Parameters

    • subcommand: "LOAD"
    • functionCode: string | Buffer
    • Optionalcallback: Callback<string>

    Returns Promise<string>

  • Parameters

    • subcommand: "LOAD"
    • replace: "REPLACE"
    • functionCode: string | Buffer
    • Optionalcallback: Callback<string>

    Returns Promise<string>

  • Restore all the functions on the given payload

    • group: scripting
    • complexity: O(N) where N is the number of functions on the payload
    • since: 7.0.0

    Parameters

    • subcommand: "RESTORE"
    • serializedValue: string | number | Buffer
    • Optionalcallback: Callback<string>

    Returns Promise<string>

  • Parameters

    • subcommand: "RESTORE"
    • serializedValue: string | number | Buffer
    • flush: "FLUSH"
    • Optionalcallback: Callback<string>

    Returns Promise<string>

  • Parameters

    • subcommand: "RESTORE"
    • serializedValue: string | number | Buffer
    • append: "APPEND"
    • Optionalcallback: Callback<string>

    Returns Promise<string>

  • Parameters

    • subcommand: "RESTORE"
    • serializedValue: string | number | Buffer
    • replace: "REPLACE"
    • Optionalcallback: Callback<string>

    Returns Promise<string>

  • Return information about the function currently running (name, description, duration)

    • group: scripting
    • complexity: O(1)
    • since: 7.0.0

    Parameters

    • subcommand: "STATS"
    • Optionalcallback: Callback<unknown>

    Returns Promise<unknown>

  • Parameters

    • subcommand: "DELETE"
    • libraryName: string | Buffer
    • Optionalcallback: Callback<Buffer>

    Returns Promise<Buffer>

  • Parameters

    • subcommand: "DUMP"
    • Optionalcallback: Callback<Buffer>

    Returns Promise<Buffer>

  • Parameters

    • subcommand: "FLUSH"
    • Optionalcallback: Callback<Buffer>

    Returns Promise<Buffer>

  • Parameters

    • subcommand: "FLUSH"
    • async: "ASYNC"
    • Optionalcallback: Callback<Buffer>

    Returns Promise<Buffer>

  • Parameters

    • subcommand: "FLUSH"
    • sync: "SYNC"
    • Optionalcallback: Callback<Buffer>

    Returns Promise<Buffer>

  • Parameters

    • subcommand: "KILL"
    • Optionalcallback: Callback<Buffer>

    Returns Promise<Buffer>

  • Parameters

    • subcommand: "LOAD"
    • functionCode: string | Buffer
    • Optionalcallback: Callback<Buffer>

    Returns Promise<Buffer>

  • Parameters

    • subcommand: "LOAD"
    • replace: "REPLACE"
    • functionCode: string | Buffer
    • Optionalcallback: Callback<Buffer>

    Returns Promise<Buffer>

  • Parameters

    • subcommand: "RESTORE"
    • serializedValue: string | number | Buffer
    • Optionalcallback: Callback<Buffer>

    Returns Promise<Buffer>

  • Parameters

    • subcommand: "RESTORE"
    • serializedValue: string | number | Buffer
    • flush: "FLUSH"
    • Optionalcallback: Callback<Buffer>

    Returns Promise<Buffer>

  • Parameters

    • subcommand: "RESTORE"
    • serializedValue: string | number | Buffer
    • append: "APPEND"
    • Optionalcallback: Callback<Buffer>

    Returns Promise<Buffer>

  • Parameters

    • subcommand: "RESTORE"
    • serializedValue: string | number | Buffer
    • replace: "REPLACE"
    • Optionalcallback: Callback<Buffer>

    Returns Promise<Buffer>

  • Add one or more geospatial items in the geospatial index represented using a sorted set

    • group: geo
    • complexity: O(log(N)) for each item added, where N is the number of elements in the sorted set.
    • since: 3.2.0

    Parameters

    • Rest...args: [key: RedisKey, ...longitudeLatitudeMembers: (string | number | Buffer)[], callback: Callback<number>]

    Returns Promise<number>

  • Parameters

    • Rest...args: [key: RedisKey, ...longitudeLatitudeMembers: (string | number | Buffer)[]]

    Returns Promise<number>

  • Parameters

    • Rest...args: [key: RedisKey, ch: "CH", ...longitudeLatitudeMembers: (string | number | Buffer)[], callback: Callback<number>]

    Returns Promise<number>

  • Parameters

    • Rest...args: [key: RedisKey, ch: "CH", ...longitudeLatitudeMembers: (string | number | Buffer)[]]

    Returns Promise<number>

  • Parameters

    • Rest...args: [key: RedisKey, nx: "NX", ...longitudeLatitudeMembers: (string | number | Buffer)[], callback: Callback<number>]

    Returns Promise<number>

  • Parameters

    • Rest...args: [key: RedisKey, nx: "NX", ...longitudeLatitudeMembers: (string | number | Buffer)[]]

    Returns Promise<number>

  • Parameters

    • Rest...args: [key: RedisKey, nx: "NX", ch: "CH", ...longitudeLatitudeMembers: (string | number | Buffer)[], callback: Callback<number>]

    Returns Promise<number>

  • Parameters

    • Rest...args: [key: RedisKey, nx: "NX", ch: "CH", ...longitudeLatitudeMembers: (string | number | Buffer)[]]

    Returns Promise<number>

  • Parameters

    • Rest...args: [key: RedisKey, xx: "XX", ...longitudeLatitudeMembers: (string | number | Buffer)[], callback: Callback<number>]

    Returns Promise<number>

  • Parameters

    • Rest...args: [key: RedisKey, xx: "XX", ...longitudeLatitudeMembers: (string | number | Buffer)[]]

    Returns Promise<number>

  • Parameters

    • Rest...args: [key: RedisKey, xx: "XX", ch: "CH", ...longitudeLatitudeMembers: (string | number | Buffer)[], callback: Callback<number>]

    Returns Promise<number>

  • Parameters

    • Rest...args: [key: RedisKey, xx: "XX", ch: "CH", ...longitudeLatitudeMembers: (string | number | Buffer)[]]

    Returns Promise<number>

  • Returns the distance between two members of a geospatial index

    • group: geo
    • complexity: O(log(N))
    • since: 3.2.0

    Parameters

    • key: RedisKey
    • member1: string | number | Buffer
    • member2: string | number | Buffer
    • Optionalcallback: Callback<null | string>

    Returns Promise<null | string>

  • Parameters

    • key: RedisKey
    • member1: string | number | Buffer
    • member2: string | number | Buffer
    • m: "M"
    • Optionalcallback: Callback<null | string>

    Returns Promise<null | string>

  • Parameters

    • key: RedisKey
    • member1: string | number | Buffer
    • member2: string | number | Buffer
    • km: "KM"
    • Optionalcallback: Callback<null | string>

    Returns Promise<null | string>

  • Parameters

    • key: RedisKey
    • member1: string | number | Buffer
    • member2: string | number | Buffer
    • ft: "FT"
    • Optionalcallback: Callback<null | string>

    Returns Promise<null | string>

  • Parameters

    • key: RedisKey
    • member1: string | number | Buffer
    • member2: string | number | Buffer
    • mi: "MI"
    • Optionalcallback: Callback<null | string>

    Returns Promise<null | string>

  • Parameters

    • key: RedisKey
    • member1: string | number | Buffer
    • member2: string | number | Buffer
    • Optionalcallback: Callback<null | Buffer>

    Returns Promise<null | Buffer>

  • Parameters

    • key: RedisKey
    • member1: string | number | Buffer
    • member2: string | number | Buffer
    • m: "M"
    • Optionalcallback: Callback<null | Buffer>

    Returns Promise<null | Buffer>

  • Parameters

    • key: RedisKey
    • member1: string | number | Buffer
    • member2: string | number | Buffer
    • km: "KM"
    • Optionalcallback: Callback<null | Buffer>

    Returns Promise<null | Buffer>

  • Parameters

    • key: RedisKey
    • member1: string | number | Buffer
    • member2: string | number | Buffer
    • ft: "FT"
    • Optionalcallback: Callback<null | Buffer>

    Returns Promise<null | Buffer>

  • Parameters

    • key: RedisKey
    • member1: string | number | Buffer
    • member2: string | number | Buffer
    • mi: "MI"
    • Optionalcallback: Callback<null | Buffer>

    Returns Promise<null | Buffer>

  • Returns members of a geospatial index as standard geohash strings

    • group: geo
    • complexity: O(log(N)) for each member requested, where N is the number of elements in the sorted set.
    • since: 3.2.0

    Parameters

    • Rest...args: [key: RedisKey, ...members: (string | number | Buffer)[], callback: Callback<string[]>]

    Returns Promise<string[]>

  • Parameters

    • Rest...args: [key: RedisKey, members: (string | number | Buffer)[], callback: Callback<string[]>]

    Returns Promise<string[]>

  • Parameters

    • Rest...args: [key: RedisKey, ...members: (string | number | Buffer)[]]

    Returns Promise<string[]>

  • Parameters

    • Rest...args: [key: RedisKey, members: (string | number | Buffer)[]]

    Returns Promise<string[]>

  • Parameters

    • Rest...args: [key: RedisKey, ...members: (string | number | Buffer)[], callback: Callback<Buffer[]>]

    Returns Promise<Buffer[]>

  • Parameters

    • Rest...args: [key: RedisKey, members: (string | number | Buffer)[], callback: Callback<Buffer[]>]

    Returns Promise<Buffer[]>

  • Parameters

    • Rest...args: [key: RedisKey, ...members: (string | number | Buffer)[]]

    Returns Promise<Buffer[]>

  • Parameters

    • Rest...args: [key: RedisKey, members: (string | number | Buffer)[]]

    Returns Promise<Buffer[]>

  • Returns longitude and latitude of members of a geospatial index

    • group: geo
    • complexity: O(N) where N is the number of members requested.
    • since: 3.2.0

    Parameters

    • Rest...args: [key: RedisKey, ...members: (string | number | Buffer)[], callback: Callback<(null | [longitude: string, latitude: string])[]>]

    Returns Promise<(null | [longitude: string, latitude: string])[]>

  • Parameters

    • Rest...args: [key: RedisKey, members: (string | number | Buffer)[], callback: Callback<(null | [longitude: string, latitude: string])[]>]

    Returns Promise<(null | [longitude: string, latitude: string])[]>

  • Parameters

    • Rest...args: [key: RedisKey, ...members: (string | number | Buffer)[]]

    Returns Promise<(null | [longitude: string, latitude: string])[]>

  • Parameters

    • Rest...args: [key: RedisKey, members: (string | number | Buffer)[]]

    Returns Promise<(null | [longitude: string, latitude: string])[]>

  • Query a sorted set representing a geospatial index to fetch members matching a given maximum distance from a point

    • group: geo
    • complexity: O(N+log(M)) where N is the number of elements inside the bounding box of the circular area delimited by center and radius and M is the number of items inside the index.
    • since: 3.2.0

    Parameters

    • Rest...args: [key: RedisKey, longitude: string | number, latitude: string | number, radius: string | number, ...args: RedisValue[], callback: Callback<unknown[]>]

    Returns Promise<unknown[]>

  • Parameters

    • Rest...args: [key: RedisKey, longitude: string | number, latitude: string | number, radius: string | number, ...args: RedisValue[]]

    Returns Promise<unknown[]>

  • A read-only variant for GEORADIUS

    • group: geo
    • complexity: O(N+log(M)) where N is the number of elements inside the bounding box of the circular area delimited by center and radius and M is the number of items inside the index.
    • since: 3.2.10

    Parameters

    • Rest...args: [key: RedisKey, longitude: string | number, latitude: string | number, radius: string | number, ...args: RedisValue[], callback: Callback<unknown>]

    Returns Promise<unknown>

  • Parameters

    • Rest...args: [key: RedisKey, longitude: string | number, latitude: string | number, radius: string | number, ...args: RedisValue[]]

    Returns Promise<unknown>

  • Query a sorted set representing a geospatial index to fetch members matching a given maximum distance from a member

    • group: geo
    • complexity: O(N+log(M)) where N is the number of elements inside the bounding box of the circular area delimited by center and radius and M is the number of items inside the index.
    • since: 3.2.0

    Parameters

    • Rest...args: [key: RedisKey, member: string | number | Buffer, radius: string | number, ...args: RedisValue[], callback: Callback<unknown>]

    Returns Promise<unknown>

  • Parameters

    • Rest...args: [key: RedisKey, member: string | number | Buffer, radius: string | number, ...args: RedisValue[]]

    Returns Promise<unknown>

  • A read-only variant for GEORADIUSBYMEMBER

    • group: geo
    • complexity: O(N+log(M)) where N is the number of elements inside the bounding box of the circular area delimited by center and radius and M is the number of items inside the index.
    • since: 3.2.10

    Parameters

    • Rest...args: [key: RedisKey, member: string | number | Buffer, radius: string | number, ...args: RedisValue[], callback: Callback<unknown>]

    Returns Promise<unknown>

  • Parameters

    • Rest...args: [key: RedisKey, member: string | number | Buffer, radius: string | number, ...args: RedisValue[]]

    Returns Promise<unknown>

  • Query a sorted set representing a geospatial index to fetch members inside an area of a box or a circle.

    • group: geo
    • complexity: O(N+log(M)) where N is the number of elements in the grid-aligned bounding box area around the shape provided as the filter and M is the number of items inside the shape
    • since: 6.2.0

    Parameters

    • Rest...args: [key: RedisKey, ...args: RedisValue[], callback: Callback<unknown[]>]

    Returns Promise<unknown[]>

  • Parameters

    • Rest...args: [key: RedisKey, ...args: RedisValue[]]

    Returns Promise<unknown[]>

  • Query a sorted set representing a geospatial index to fetch members inside an area of a box or a circle, and store the result in another key.

    • group: geo
    • complexity: O(N+log(M)) where N is the number of elements in the grid-aligned bounding box area around the shape provided as the filter and M is the number of items inside the shape
    • since: 6.2.0

    Parameters

    • Rest...args: [destination: RedisKey, source: RedisKey, ...args: RedisValue[], callback: Callback<number>]

    Returns Promise<number>

  • Parameters

    • Rest...args: [destination: RedisKey, source: RedisKey, ...args: RedisValue[]]

    Returns Promise<number>

  • Get the value of a key

    • group: string
    • complexity: O(1)
    • since: 1.0.0

    Parameters

    • key: RedisKey
    • Optionalcallback: Callback<null | string>

    Returns Promise<null | string>

  • Returns the bit value at offset in the string value stored at key

    • group: bitmap
    • complexity: O(1)
    • since: 2.2.0

    Parameters

    • key: RedisKey
    • offset: string | number
    • Optionalcallback: Callback<number>

    Returns Promise<number>

  • Parameters

    • key: RedisKey
    • Optionalcallback: Callback<null | Buffer>

    Returns Promise<null | Buffer>

  • Return supported builtin commands

    Returns string[]

  • Get the value of a key and delete the key

    • group: string
    • complexity: O(1)
    • since: 6.2.0

    Parameters

    • key: RedisKey
    • Optionalcallback: Callback<null | string>

    Returns Promise<null | string>

  • Parameters

    • key: RedisKey
    • Optionalcallback: Callback<null | Buffer>

    Returns Promise<null | Buffer>

  • Get the value of a key and optionally set its expiration

    • group: string
    • complexity: O(1)
    • since: 6.2.0

    Parameters

    • key: RedisKey
    • Optionalcallback: Callback<null | string>

    Returns Promise<null | string>

  • Parameters

    • key: RedisKey
    • secondsToken: "EX"
    • seconds: string | number
    • Optionalcallback: Callback<null | string>

    Returns Promise<null | string>

  • Parameters

    • key: RedisKey
    • millisecondsToken: "PX"
    • milliseconds: string | number
    • Optionalcallback: Callback<null | string>

    Returns Promise<null | string>

  • Parameters

    • key: RedisKey
    • unixTimeSecondsToken: "EXAT"
    • unixTimeSeconds: string | number
    • Optionalcallback: Callback<null | string>

    Returns Promise<null | string>

  • Parameters

    • key: RedisKey
    • unixTimeMillisecondsToken: "PXAT"
    • unixTimeMilliseconds: string | number
    • Optionalcallback: Callback<null | string>

    Returns Promise<null | string>

  • Parameters

    • key: RedisKey
    • persist: "PERSIST"
    • Optionalcallback: Callback<null | string>

    Returns Promise<null | string>

  • Parameters

    • key: RedisKey
    • Optionalcallback: Callback<null | Buffer>

    Returns Promise<null | Buffer>

  • Parameters

    • key: RedisKey
    • secondsToken: "EX"
    • seconds: string | number
    • Optionalcallback: Callback<null | Buffer>

    Returns Promise<null | Buffer>

  • Parameters

    • key: RedisKey
    • millisecondsToken: "PX"
    • milliseconds: string | number
    • Optionalcallback: Callback<null | Buffer>

    Returns Promise<null | Buffer>

  • Parameters

    • key: RedisKey
    • unixTimeSecondsToken: "EXAT"
    • unixTimeSeconds: string | number
    • Optionalcallback: Callback<null | Buffer>

    Returns Promise<null | Buffer>

  • Parameters

    • key: RedisKey
    • unixTimeMillisecondsToken: "PXAT"
    • unixTimeMilliseconds: string | number
    • Optionalcallback: Callback<null | Buffer>

    Returns Promise<null | Buffer>

  • Parameters

    • key: RedisKey
    • persist: "PERSIST"
    • Optionalcallback: Callback<null | Buffer>

    Returns Promise<null | Buffer>

  • Returns the current max listener value for the EventEmitter which is either set by emitter.setMaxListeners(n) or defaults to defaultMaxListeners.

    Returns number

    v1.0.0

  • Get a substring of the string stored at a key

    • group: string
    • complexity: O(N) where N is the length of the returned string. The complexity is ultimately determined by the returned length, but because creating a substring from an existing string is very cheap, it can be considered O(1) for small strings.
    • since: 2.4.0

    Parameters

    • key: RedisKey
    • start: string | number
    • end: string | number
    • Optionalcallback: Callback<string>

    Returns Promise<string>

  • Parameters

    • key: RedisKey
    • start: string | number
    • end: string | number
    • Optionalcallback: Callback<Buffer>

    Returns Promise<Buffer>

  • Set the string value of a key and return its old value

    • group: string
    • complexity: O(1)
    • since: 1.0.0

    Parameters

    • key: RedisKey
    • value: string | number | Buffer
    • Optionalcallback: Callback<null | string>

    Returns Promise<null | string>

  • Parameters

    • key: RedisKey
    • value: string | number | Buffer
    • Optionalcallback: Callback<null | Buffer>

    Returns Promise<null | Buffer>

  • Delete one or more hash fields

    • group: hash
    • complexity: O(N) where N is the number of fields to be removed.
    • since: 2.0.0

    Parameters

    • Rest...args: [key: RedisKey, ...fields: (string | Buffer)[], callback: Callback<number>]

    Returns Promise<number>

  • Parameters

    • Rest...args: [key: RedisKey, ...fields: (string | Buffer)[]]

    Returns Promise<number>

  • Handshake with Redis

    • group: connection
    • complexity: O(1)
    • since: 6.0.0

    Parameters

    • Optionalcallback: Callback<unknown[]>

    Returns Promise<unknown[]>

  • Parameters

    • protover: string | number
    • Optionalcallback: Callback<unknown[]>

    Returns Promise<unknown[]>

  • Parameters

    • protover: string | number
    • clientnameToken: "SETNAME"
    • clientname: string | Buffer
    • Optionalcallback: Callback<unknown[]>

    Returns Promise<unknown[]>

  • Parameters

    • protover: string | number
    • usernamePasswordToken: "AUTH"
    • username: string | Buffer
    • password: string | Buffer
    • Optionalcallback: Callback<unknown[]>

    Returns Promise<unknown[]>

  • Parameters

    • protover: string | number
    • usernamePasswordToken: "AUTH"
    • username: string | Buffer
    • password: string | Buffer
    • clientnameToken: "SETNAME"
    • clientname: string | Buffer
    • Optionalcallback: Callback<unknown[]>

    Returns Promise<unknown[]>

  • Determine if a hash field exists

    • group: hash
    • complexity: O(1)
    • since: 2.0.0

    Parameters

    • key: RedisKey
    • field: string | Buffer
    • Optionalcallback: Callback<number>

    Returns Promise<number>

  • Get the value of a hash field

    • group: hash
    • complexity: O(1)
    • since: 2.0.0

    Parameters

    • key: RedisKey
    • field: string | Buffer
    • Optionalcallback: Callback<null | string>

    Returns Promise<null | string>

  • Get all the fields and values in a hash

    • group: hash
    • complexity: O(N) where N is the size of the hash.
    • since: 2.0.0

    Parameters

    • key: RedisKey
    • Optionalcallback: Callback<Record<string, string>>

    Returns Promise<Record<string, string>>

  • Parameters

    • key: RedisKey
    • Optionalcallback: Callback<Record<string, Buffer>>

    Returns Promise<Record<string, Buffer>>

  • Parameters

    • key: RedisKey
    • field: string | Buffer
    • Optionalcallback: Callback<null | Buffer>

    Returns Promise<null | Buffer>

  • Increment the integer value of a hash field by the given number

    • group: hash
    • complexity: O(1)
    • since: 2.0.0

    Parameters

    • key: RedisKey
    • field: string | Buffer
    • increment: string | number
    • Optionalcallback: Callback<number>

    Returns Promise<number>

  • Increment the float value of a hash field by the given amount

    • group: hash
    • complexity: O(1)
    • since: 2.6.0

    Parameters

    • key: RedisKey
    • field: string | Buffer
    • increment: string | number
    • Optionalcallback: Callback<string>

    Returns Promise<string>

  • Parameters

    • key: RedisKey
    • field: string | Buffer
    • increment: string | number
    • Optionalcallback: Callback<Buffer>

    Returns Promise<Buffer>

  • Get all the fields in a hash

    • group: hash
    • complexity: O(N) where N is the size of the hash.
    • since: 2.0.0

    Parameters

    • key: RedisKey
    • Optionalcallback: Callback<string[]>

    Returns Promise<string[]>

  • Parameters

    • key: RedisKey
    • Optionalcallback: Callback<Buffer[]>

    Returns Promise<Buffer[]>

  • Get the number of fields in a hash

    • group: hash
    • complexity: O(1)
    • since: 2.0.0

    Parameters

    • key: RedisKey
    • Optionalcallback: Callback<number>

    Returns Promise<number>

  • Get the values of all the given hash fields

    • group: hash
    • complexity: O(N) where N is the number of fields being requested.
    • since: 2.0.0

    Parameters

    • Rest...args: [key: RedisKey, ...fields: (string | Buffer)[], callback: Callback<(null | string)[]>]

    Returns Promise<(null | string)[]>

  • Parameters

    • Rest...args: [key: RedisKey, ...fields: (string | Buffer)[]]

    Returns Promise<(null | string)[]>

  • Parameters

    • Rest...args: [key: RedisKey, ...fields: (string | Buffer)[], callback: Callback<(null | Buffer)[]>]

    Returns Promise<(null | Buffer)[]>

  • Parameters

    • Rest...args: [key: RedisKey, ...fields: (string | Buffer)[]]

    Returns Promise<(null | Buffer)[]>

  • Set multiple hash fields to multiple values

    • group: hash
    • complexity: O(N) where N is the number of fields being set.
    • since: 2.0.0

    Parameters

    • key: RedisKey
    • object: object
    • Optionalcallback: Callback<"OK">

    Returns Promise<"OK">

  • Parameters

    • key: RedisKey
    • map: Map<string | number | Buffer, string | number | Buffer>
    • Optionalcallback: Callback<"OK">

    Returns Promise<"OK">

  • Parameters

    • Rest...args: [key: RedisKey, ...fieldValues: (string | number | Buffer)[], callback: Callback<"OK">]

    Returns Promise<"OK">

  • Parameters

    • Rest...args: [key: RedisKey, ...fieldValues: (string | number | Buffer)[]]

    Returns Promise<"OK">

  • Get one or multiple random fields from a hash

    • group: hash
    • complexity: O(N) where N is the number of fields returned
    • since: 6.2.0

    Parameters

    • key: RedisKey
    • Optionalcallback: Callback<null | string | unknown[]>

    Returns Promise<null | string | unknown[]>

  • Parameters

    • key: RedisKey
    • count: string | number
    • Optionalcallback: Callback<null | string | unknown[]>

    Returns Promise<null | string | unknown[]>

  • Parameters

    • key: RedisKey
    • count: string | number
    • withvalues: "WITHVALUES"
    • Optionalcallback: Callback<null | string | unknown[]>

    Returns Promise<null | string | unknown[]>

  • Parameters

    • key: RedisKey
    • Optionalcallback: Callback<null | unknown[] | Buffer>

    Returns Promise<null | unknown[] | Buffer>

  • Parameters

    • key: RedisKey
    • count: string | number
    • Optionalcallback: Callback<null | unknown[] | Buffer>

    Returns Promise<null | unknown[] | Buffer>

  • Parameters

    • key: RedisKey
    • count: string | number
    • withvalues: "WITHVALUES"
    • Optionalcallback: Callback<null | unknown[] | Buffer>

    Returns Promise<null | unknown[] | Buffer>

  • Incrementally iterate hash fields and associated values

    • group: hash
    • complexity: O(1) for every call. O(N) for a complete iteration, including enough command calls for the cursor to return back to 0. N is the number of elements inside the collection..
    • since: 2.8.0

    Parameters

    • key: RedisKey
    • cursor: string | number
    • Optionalcallback: Callback<[cursor: string, elements: string[]]>

    Returns Promise<[cursor: string, elements: string[]]>

  • Parameters

    • key: RedisKey
    • cursor: string | number
    • countToken: "COUNT"
    • count: string | number
    • Optionalcallback: Callback<[cursor: string, elements: string[]]>

    Returns Promise<[cursor: string, elements: string[]]>

  • Parameters

    • key: RedisKey
    • cursor: string | number
    • patternToken: "MATCH"
    • pattern: string
    • Optionalcallback: Callback<[cursor: string, elements: string[]]>

    Returns Promise<[cursor: string, elements: string[]]>

  • Parameters

    • key: RedisKey
    • cursor: string | number
    • patternToken: "MATCH"
    • pattern: string
    • countToken: "COUNT"
    • count: string | number
    • Optionalcallback: Callback<[cursor: string, elements: string[]]>

    Returns Promise<[cursor: string, elements: string[]]>

  • Parameters

    • key: RedisKey
    • cursor: string | number
    • Optionalcallback: Callback<[cursor: Buffer, elements: Buffer[]]>

    Returns Promise<[cursor: Buffer, elements: Buffer[]]>

  • Parameters

    • key: RedisKey
    • cursor: string | number
    • countToken: "COUNT"
    • count: string | number
    • Optionalcallback: Callback<[cursor: Buffer, elements: Buffer[]]>

    Returns Promise<[cursor: Buffer, elements: Buffer[]]>

  • Parameters

    • key: RedisKey
    • cursor: string | number
    • patternToken: "MATCH"
    • pattern: string
    • Optionalcallback: Callback<[cursor: Buffer, elements: Buffer[]]>

    Returns Promise<[cursor: Buffer, elements: Buffer[]]>

  • Parameters

    • key: RedisKey
    • cursor: string | number
    • patternToken: "MATCH"
    • pattern: string
    • countToken: "COUNT"
    • count: string | number
    • Optionalcallback: Callback<[cursor: Buffer, elements: Buffer[]]>

    Returns Promise<[cursor: Buffer, elements: Buffer[]]>

  • Parameters

    • key: string
    • Optionaloptions: ScanStreamOptions

    Returns ScanStream

  • Parameters

    • key: string
    • Optionaloptions: ScanStreamOptions

    Returns ScanStream

  • Set the string value of a hash field

    • group: hash
    • complexity: O(1) for each field/value pair added, so O(N) to add N field/value pairs when the command is called with multiple field/value pairs.
    • since: 2.0.0

    Parameters

    • key: RedisKey
    • object: object
    • Optionalcallback: Callback<number>

    Returns Promise<number>

  • Parameters

    • key: RedisKey
    • map: Map<string | number | Buffer, string | number | Buffer>
    • Optionalcallback: Callback<number>

    Returns Promise<number>

  • Parameters

    • Rest...args: [key: RedisKey, ...fieldValues: (string | number | Buffer)[], callback: Callback<number>]

    Returns Promise<number>

  • Parameters

    • Rest...args: [key: RedisKey, ...fieldValues: (string | number | Buffer)[]]

    Returns Promise<number>

  • Set the value of a hash field, only if the field does not exist

    • group: hash
    • complexity: O(1)
    • since: 2.0.0

    Parameters

    • key: RedisKey
    • field: string | Buffer
    • value: string | number | Buffer
    • Optionalcallback: Callback<number>

    Returns Promise<number>

  • Get the length of the value of a hash field

    • group: hash
    • complexity: O(1)
    • since: 3.2.0

    Parameters

    • key: RedisKey
    • field: string | Buffer
    • Optionalcallback: Callback<number>

    Returns Promise<number>

  • Get all the values in a hash

    • group: hash
    • complexity: O(N) where N is the size of the hash.
    • since: 2.0.0

    Parameters

    • key: RedisKey
    • Optionalcallback: Callback<string[]>

    Returns Promise<string[]>

  • Parameters

    • key: RedisKey
    • Optionalcallback: Callback<Buffer[]>

    Returns Promise<Buffer[]>

  • Increment the integer value of a key by one

    • group: string
    • complexity: O(1)
    • since: 1.0.0

    Parameters

    • key: RedisKey
    • Optionalcallback: Callback<number>

    Returns Promise<number>

  • Increment the integer value of a key by the given amount

    • group: string
    • complexity: O(1)
    • since: 1.0.0

    Parameters

    • key: RedisKey
    • increment: string | number
    • Optionalcallback: Callback<number>

    Returns Promise<number>

  • Increment the float value of a key by the given amount

    • group: string
    • complexity: O(1)
    • since: 2.6.0

    Parameters

    • key: RedisKey
    • increment: string | number
    • Optionalcallback: Callback<string>

    Returns Promise<string>

  • Get information and statistics about the server

    • group: server
    • complexity: O(1)
    • since: 1.0.0

    Parameters

    • Optionalcallback: Callback<string>

    Returns Promise<string>

  • Parameters

    • Rest...args: [...sections: (string | Buffer)[], callback: Callback<string>]

    Returns Promise<string>

  • Parameters

    • Rest...args: (string | Buffer)[]

    Returns Promise<string>

  • Find all keys matching the given pattern

    • group: generic
    • complexity: O(N) with N being the number of keys in the database, under the assumption that the key names in the database and the given pattern have limited length.
    • since: 1.0.0

    Parameters

    • pattern: string
    • Optionalcallback: Callback<string[]>

    Returns Promise<string[]>

  • Parameters

    • pattern: string
    • Optionalcallback: Callback<Buffer[]>

    Returns Promise<Buffer[]>

  • Get the UNIX time stamp of the last successful save to disk

    • group: server
    • complexity: O(1)
    • since: 1.0.0

    Parameters

    • Optionalcallback: Callback<number>

    Returns Promise<number>

  • Return a human readable latency analysis report.

    • group: server
    • complexity: O(1)
    • since: 2.8.13

    Parameters

    • subcommand: "DOCTOR"
    • Optionalcallback: Callback<string>

    Returns Promise<string>

  • Return a latency graph for the event.

    • group: server
    • complexity: O(1)
    • since: 2.8.13

    Parameters

    • subcommand: "GRAPH"
    • event: string | Buffer
    • Optionalcallback: Callback<string>

    Returns Promise<string>

  • Show helpful text about the different subcommands.

    • group: server
    • complexity: O(1)
    • since: 2.8.13

    Parameters

    • subcommand: "HELP"
    • Optionalcallback: Callback<unknown[]>

    Returns Promise<unknown[]>

  • Return the cumulative distribution of latencies of a subset of commands or all.

    • group: server
    • complexity: O(N) where N is the number of commands with latency information being retrieved.
    • since: 7.0.0

    Parameters

    • subcommand: "HISTOGRAM"
    • Optionalcallback: Callback<unknown>

    Returns Promise<unknown>

  • Parameters

    • Rest...args: [subcommand: "HISTOGRAM", ...commands: (string | Buffer)[], callback: Callback<unknown>]

    Returns Promise<unknown>

  • Parameters

    • Rest...args: [subcommand: "HISTOGRAM", ...commands: (string | Buffer)[]]

    Returns Promise<unknown>

  • Return timestamp-latency samples for the event.

    • group: server
    • complexity: O(1)
    • since: 2.8.13

    Parameters

    • subcommand: "HISTORY"
    • event: string | Buffer
    • Optionalcallback: Callback<unknown[]>

    Returns Promise<unknown[]>

  • Return the latest latency samples for all events.

    • group: server
    • complexity: O(1)
    • since: 2.8.13

    Parameters

    • subcommand: "LATEST"
    • Optionalcallback: Callback<unknown[]>

    Returns Promise<unknown[]>

  • Reset latency data for one or more events.

    • group: server
    • complexity: O(1)
    • since: 2.8.13

    Parameters

    • subcommand: "RESET"
    • Optionalcallback: Callback<number>

    Returns Promise<number>

  • Parameters

    • Rest...args: [subcommand: "RESET", ...events: (string | Buffer)[], callback: Callback<number>]

    Returns Promise<number>

  • Parameters

    • Rest...args: [subcommand: "RESET", ...events: (string | Buffer)[]]

    Returns Promise<number>

  • Find longest common substring

    • group: string
    • complexity: O(N*M) where N and M are the lengths of s1 and s2, respectively
    • since: 7.0.0

    Parameters

    • key1: RedisKey
    • key2: RedisKey
    • Optionalcallback: Callback<unknown>

    Returns Promise<unknown>

  • Parameters

    • key1: RedisKey
    • key2: RedisKey
    • withmatchlen: "WITHMATCHLEN"
    • Optionalcallback: Callback<unknown>

    Returns Promise<unknown>

  • Parameters

    • key1: RedisKey
    • key2: RedisKey
    • lenToken: "MINMATCHLEN"
    • len: string | number
    • Optionalcallback: Callback<unknown>

    Returns Promise<unknown>

  • Parameters

    • key1: RedisKey
    • key2: RedisKey
    • lenToken: "MINMATCHLEN"
    • len: string | number
    • withmatchlen: "WITHMATCHLEN"
    • Optionalcallback: Callback<unknown>

    Returns Promise<unknown>

  • Parameters

    • key1: RedisKey
    • key2: RedisKey
    • idx: "IDX"
    • Optionalcallback: Callback<unknown>

    Returns Promise<unknown>

  • Parameters

    • key1: RedisKey
    • key2: RedisKey
    • idx: "IDX"
    • withmatchlen: "WITHMATCHLEN"
    • Optionalcallback: Callback<unknown>

    Returns Promise<unknown>

  • Parameters

    • key1: RedisKey
    • key2: RedisKey
    • idx: "IDX"
    • lenToken: "MINMATCHLEN"
    • len: string | number
    • Optionalcallback: Callback<unknown>

    Returns Promise<unknown>

  • Parameters

    • key1: RedisKey
    • key2: RedisKey
    • idx: "IDX"
    • lenToken: "MINMATCHLEN"
    • len: string | number
    • withmatchlen: "WITHMATCHLEN"
    • Optionalcallback: Callback<unknown>

    Returns Promise<unknown>

  • Parameters

    • key1: RedisKey
    • key2: RedisKey
    • len: "LEN"
    • Optionalcallback: Callback<unknown>

    Returns Promise<unknown>

  • Parameters

    • key1: RedisKey
    • key2: RedisKey
    • len: "LEN"
    • withmatchlen: "WITHMATCHLEN"
    • Optionalcallback: Callback<unknown>

    Returns Promise<unknown>

  • Parameters

    • key1: RedisKey
    • key2: RedisKey
    • len: "LEN"
    • lenToken: "MINMATCHLEN"
    • len1: string | number
    • Optionalcallback: Callback<unknown>

    Returns Promise<unknown>

  • Parameters

    • key1: RedisKey
    • key2: RedisKey
    • len: "LEN"
    • lenToken: "MINMATCHLEN"
    • len1: string | number
    • withmatchlen: "WITHMATCHLEN"
    • Optionalcallback: Callback<unknown>

    Returns Promise<unknown>

  • Parameters

    • key1: RedisKey
    • key2: RedisKey
    • len: "LEN"
    • idx: "IDX"
    • Optionalcallback: Callback<unknown>

    Returns Promise<unknown>

  • Parameters

    • key1: RedisKey
    • key2: RedisKey
    • len: "LEN"
    • idx: "IDX"
    • withmatchlen: "WITHMATCHLEN"
    • Optionalcallback: Callback<unknown>

    Returns Promise<unknown>

  • Parameters

    • key1: RedisKey
    • key2: RedisKey
    • len: "LEN"
    • idx: "IDX"
    • lenToken: "MINMATCHLEN"
    • len1: string | number
    • Optionalcallback: Callback<unknown>

    Returns Promise<unknown>

  • Parameters

    • key1: RedisKey
    • key2: RedisKey
    • len: "LEN"
    • idx: "IDX"
    • lenToken: "MINMATCHLEN"
    • len1: string | number
    • withmatchlen: "WITHMATCHLEN"
    • Optionalcallback: Callback<unknown>

    Returns Promise<unknown>

  • Get an element from a list by its index

    • group: list
    • complexity: O(N) where N is the number of elements to traverse to get to the element at index. This makes asking for the first or the last element of the list O(1).
    • since: 1.0.0

    Parameters

    • key: RedisKey
    • index: string | number
    • Optionalcallback: Callback<null | string>

    Returns Promise<null | string>

  • Parameters

    • key: RedisKey
    • index: string | number
    • Optionalcallback: Callback<null | Buffer>

    Returns Promise<null | Buffer>

  • Insert an element before or after another element in a list

    • group: list
    • complexity: O(N) where N is the number of elements to traverse before seeing the value pivot. This means that inserting somewhere on the left end on the list (head) can be considered O(1) and inserting somewhere on the right end (tail) is O(N).
    • since: 2.2.0

    Parameters

    • key: RedisKey
    • before: "BEFORE"
    • pivot: string | number | Buffer
    • element: string | number | Buffer
    • Optionalcallback: Callback<number>

    Returns Promise<number>

  • Parameters

    • key: RedisKey
    • after: "AFTER"
    • pivot: string | number | Buffer
    • element: string | number | Buffer
    • Optionalcallback: Callback<number>

    Returns Promise<number>

  • Returns the number of listeners listening for the event named eventName. If listener is provided, it will return how many times the listener is found in the list of the listeners of the event.

    Type Parameters

    • K

    Parameters

    • eventName: string | symbol

      The name of the event being listened for

    • Optionallistener: Function

      The event handler function

    Returns number

    v3.2.0

  • Returns a copy of the array of listeners for the event named eventName.

    server.on('connection', (stream) => {
    console.log('someone connected!');
    });
    console.log(util.inspect(server.listeners('connection')));
    // Prints: [ [Function] ]

    Type Parameters

    • K

    Parameters

    • eventName: string | symbol

    Returns Function[]

    v0.1.26

  • Get the length of a list

    • group: list
    • complexity: O(1)
    • since: 1.0.0

    Parameters

    • key: RedisKey
    • Optionalcallback: Callback<number>

    Returns Promise<number>

  • Pop an element from a list, push it to another list and return it

    • group: list
    • complexity: O(1)
    • since: 6.2.0

    Parameters

    • source: RedisKey
    • destination: RedisKey
    • left: "LEFT"
    • left1: "LEFT"
    • Optionalcallback: Callback<string>

    Returns Promise<string>

  • Parameters

    • source: RedisKey
    • destination: RedisKey
    • left: "LEFT"
    • right: "RIGHT"
    • Optionalcallback: Callback<string>

    Returns Promise<string>

  • Parameters

    • source: RedisKey
    • destination: RedisKey
    • right: "RIGHT"
    • left: "LEFT"
    • Optionalcallback: Callback<string>

    Returns Promise<string>

  • Parameters

    • source: RedisKey
    • destination: RedisKey
    • right: "RIGHT"
    • right1: "RIGHT"
    • Optionalcallback: Callback<string>

    Returns Promise<string>

  • Parameters

    • source: RedisKey
    • destination: RedisKey
    • left: "LEFT"
    • left1: "LEFT"
    • Optionalcallback: Callback<Buffer>

    Returns Promise<Buffer>

  • Parameters

    • source: RedisKey
    • destination: RedisKey
    • left: "LEFT"
    • right: "RIGHT"
    • Optionalcallback: Callback<Buffer>

    Returns Promise<Buffer>

  • Parameters

    • source: RedisKey
    • destination: RedisKey
    • right: "RIGHT"
    • left: "LEFT"
    • Optionalcallback: Callback<Buffer>

    Returns Promise<Buffer>

  • Parameters

    • source: RedisKey
    • destination: RedisKey
    • right: "RIGHT"
    • right1: "RIGHT"
    • Optionalcallback: Callback<Buffer>

    Returns Promise<Buffer>

  • Pop elements from a list

    • group: list
    • complexity: O(N+M) where N is the number of provided keys and M is the number of elements returned.
    • since: 7.0.0

    Parameters

    • Rest...args: [numkeys: string | number, ...keys: RedisKey[], left: "LEFT", callback: Callback<null | [key: string, members: string[]]>]

    Returns Promise<null | [key: string, members: string[]]>

  • Parameters

    • Rest...args: [numkeys: string | number, keys: RedisKey[], left: "LEFT", callback: Callback<null | [key: string, members: string[]]>]

    Returns Promise<null | [key: string, members: string[]]>

  • Parameters

    • Rest...args: [numkeys: string | number, ...keys: RedisKey[], left: "LEFT"]

    Returns Promise<null | [key: string, members: string[]]>

  • Parameters

    • Rest...args: [numkeys: string | number, keys: RedisKey[], left: "LEFT"]

    Returns Promise<null | [key: string, members: string[]]>

  • Parameters

    • Rest...args: [numkeys: string | number, ...keys: RedisKey[], left: "LEFT", countToken: "COUNT", count: string | number, callback: Callback<null | [key: string, members: string[]]>]

    Returns Promise<null | [key: string, members: string[]]>

  • Parameters

    • Rest...args: [numkeys: string | number, keys: RedisKey[], left: "LEFT", countToken: "COUNT", count: string | number, callback: Callback<null | [key: string, members: string[]]>]

    Returns Promise<null | [key: string, members: string[]]>

  • Parameters

    • Rest...args: [numkeys: string | number, ...keys: RedisKey[], left: "LEFT", countToken: "COUNT", count: string | number]

    Returns Promise<null | [key: string, members: string[]]>

  • Parameters

    • Rest...args: [numkeys: string | number, keys: RedisKey[], left: "LEFT", countToken: "COUNT", count: string | number]

    Returns Promise<null | [key: string, members: string[]]>

  • Parameters

    • Rest...args: [numkeys: string | number, ...keys: RedisKey[], right: "RIGHT", callback: Callback<null | [key: string, members: string[]]>]

    Returns Promise<null | [key: string, members: string[]]>

  • Parameters

    • Rest...args: [numkeys: string | number, keys: RedisKey[], right: "RIGHT", callback: Callback<null | [key: string, members: string[]]>]

    Returns Promise<null | [key: string, members: string[]]>

  • Parameters

    • Rest...args: [numkeys: string | number, ...keys: RedisKey[], right: "RIGHT"]

    Returns Promise<null | [key: string, members: string[]]>

  • Parameters

    • Rest...args: [numkeys: string | number, keys: RedisKey[], right: "RIGHT"]

    Returns Promise<null | [key: string, members: string[]]>

  • Parameters

    • Rest...args: [numkeys: string | number, ...keys: RedisKey[], right: "RIGHT", countToken: "COUNT", count: string | number, callback: Callback<null | [key: string, members: string[]]>]

    Returns Promise<null | [key: string, members: string[]]>

  • Parameters

    • Rest...args: [numkeys: string | number, keys: RedisKey[], right: "RIGHT", countToken: "COUNT", count: string | number, callback: Callback<null | [key: string, members: string[]]>]

    Returns Promise<null | [key: string, members: string[]]>

  • Parameters

    • Rest...args: [numkeys: string | number, ...keys: RedisKey[], right: "RIGHT", countToken: "COUNT", count: string | number]

    Returns Promise<null | [key: string, members: string[]]>

  • Parameters

    • Rest...args: [numkeys: string | number, keys: RedisKey[], right: "RIGHT", countToken: "COUNT", count: string | number]

    Returns Promise<null | [key: string, members: string[]]>

  • Parameters

    • Rest...args: [numkeys: string | number, ...keys: RedisKey[], left: "LEFT", callback: Callback<null | [key: Buffer, members: Buffer[]]>]

    Returns Promise<null | [key: Buffer, members: Buffer[]]>

  • Parameters

    • Rest...args: [numkeys: string | number, keys: RedisKey[], left: "LEFT", callback: Callback<null | [key: Buffer, members: Buffer[]]>]

    Returns Promise<null | [key: Buffer, members: Buffer[]]>

  • Parameters

    • Rest...args: [numkeys: string | number, ...keys: RedisKey[], left: "LEFT"]

    Returns Promise<null | [key: Buffer, members: Buffer[]]>

  • Parameters

    • Rest...args: [numkeys: string | number, keys: RedisKey[], left: "LEFT"]

    Returns Promise<null | [key: Buffer, members: Buffer[]]>

  • Parameters

    • Rest...args: [numkeys: string | number, ...keys: RedisKey[], left: "LEFT", countToken: "COUNT", count: string | number, callback: Callback<null | [key: Buffer, members: Buffer[]]>]

    Returns Promise<null | [key: Buffer, members: Buffer[]]>

  • Parameters

    • Rest...args: [numkeys: string | number, keys: RedisKey[], left: "LEFT", countToken: "COUNT", count: string | number, callback: Callback<null | [key: Buffer, members: Buffer[]]>]

    Returns Promise<null | [key: Buffer, members: Buffer[]]>

  • Parameters

    • Rest...args: [numkeys: string | number, ...keys: RedisKey[], left: "LEFT", countToken: "COUNT", count: string | number]

    Returns Promise<null | [key: Buffer, members: Buffer[]]>

  • Parameters

    • Rest...args: [numkeys: string | number, keys: RedisKey[], left: "LEFT", countToken: "COUNT", count: string | number]

    Returns Promise<null | [key: Buffer, members: Buffer[]]>

  • Parameters

    • Rest...args: [numkeys: string | number, ...keys: RedisKey[], right: "RIGHT", callback: Callback<null | [key: Buffer, members: Buffer[]]>]

    Returns Promise<null | [key: Buffer, members: Buffer[]]>

  • Parameters

    • Rest...args: [numkeys: string | number, keys: RedisKey[], right: "RIGHT", callback: Callback<null | [key: Buffer, members: Buffer[]]>]

    Returns Promise<null | [key: Buffer, members: Buffer[]]>

  • Parameters

    • Rest...args: [numkeys: string | number, ...keys: RedisKey[], right: "RIGHT"]

    Returns Promise<null | [key: Buffer, members: Buffer[]]>

  • Parameters

    • Rest...args: [numkeys: string | number, keys: RedisKey[], right: "RIGHT"]

    Returns Promise<null | [key: Buffer, members: Buffer[]]>

  • Parameters

    • Rest...args: [numkeys: string | number, ...keys: RedisKey[], right: "RIGHT", countToken: "COUNT", count: string | number, callback: Callback<null | [key: Buffer, members: Buffer[]]>]

    Returns Promise<null | [key: Buffer, members: Buffer[]]>

  • Parameters

    • Rest...args: [numkeys: string | number, keys: RedisKey[], right: "RIGHT", countToken: "COUNT", count: string | number, callback: Callback<null | [key: Buffer, members: Buffer[]]>]

    Returns Promise<null | [key: Buffer, members: Buffer[]]>

  • Parameters

    • Rest...args: [numkeys: string | number, ...keys: RedisKey[], right: "RIGHT", countToken: "COUNT", count: string | number]

    Returns Promise<null | [key: Buffer, members: Buffer[]]>

  • Parameters

    • Rest...args: [numkeys: string | number, keys: RedisKey[], right: "RIGHT", countToken: "COUNT", count: string | number]

    Returns Promise<null | [key: Buffer, members: Buffer[]]>

  • Display some computer art and the Redis version

    • group: server
    • complexity: undefined
    • since: 5.0.0

    Parameters

    • Optionalcallback: Callback<string>

    Returns Promise<string>

  • Parameters

    • versionToken: "VERSION"
    • version: string | number
    • Optionalcallback: Callback<string>

    Returns Promise<string>

  • Remove and get the first elements in a list

    • group: list
    • complexity: O(N) where N is the number of elements returned
    • since: 1.0.0

    Parameters

    • key: RedisKey
    • Optionalcallback: Callback<null | string>

    Returns Promise<null | string>

  • Parameters

    • key: RedisKey
    • count: string | number
    • Optionalcallback: Callback<null | string[]>

    Returns Promise<null | string[]>

  • Parameters

    • key: RedisKey
    • Optionalcallback: Callback<null | Buffer>

    Returns Promise<null | Buffer>

  • Parameters

    • key: RedisKey
    • count: string | number
    • Optionalcallback: Callback<null | Buffer[]>

    Returns Promise<null | Buffer[]>

  • Return the index of matching elements on a list

    • group: list
    • complexity: O(N) where N is the number of elements in the list, for the average case. When searching for elements near the head or the tail of the list, or when the MAXLEN option is provided, the command may run in constant time.
    • since: 6.0.6

    Parameters

    • key: RedisKey
    • element: string | number | Buffer
    • Optionalcallback: Callback<null | number>

    Returns Promise<null | number>

  • Parameters

    • key: RedisKey
    • element: string | number | Buffer
    • lenToken: "MAXLEN"
    • len: string | number
    • Optionalcallback: Callback<null | number>

    Returns Promise<null | number>

  • Parameters

    • key: RedisKey
    • element: string | number | Buffer
    • numMatchesToken: "COUNT"
    • numMatches: string | number
    • Optionalcallback: Callback<number[]>

    Returns Promise<number[]>

  • Parameters

    • key: RedisKey
    • element: string | number | Buffer
    • numMatchesToken: "COUNT"
    • numMatches: string | number
    • lenToken: "MAXLEN"
    • len: string | number
    • Optionalcallback: Callback<number[]>

    Returns Promise<number[]>

  • Parameters

    • key: RedisKey
    • element: string | number | Buffer
    • rankToken: "RANK"
    • rank: string | number
    • Optionalcallback: Callback<null | number>

    Returns Promise<null | number>

  • Parameters

    • key: RedisKey
    • element: string | number | Buffer
    • rankToken: "RANK"
    • rank: string | number
    • lenToken: "MAXLEN"
    • len: string | number
    • Optionalcallback: Callback<null | number>

    Returns Promise<null | number>

  • Parameters

    • key: RedisKey
    • element: string | number | Buffer
    • rankToken: "RANK"
    • rank: string | number
    • numMatchesToken: "COUNT"
    • numMatches: string | number
    • Optionalcallback: Callback<number[]>

    Returns Promise<number[]>

  • Parameters

    • key: RedisKey
    • element: string | number | Buffer
    • rankToken: "RANK"
    • rank: string | number
    • numMatchesToken: "COUNT"
    • numMatches: string | number
    • lenToken: "MAXLEN"
    • len: string | number
    • Optionalcallback: Callback<number[]>

    Returns Promise<number[]>

  • Prepend one or multiple elements to a list

    • group: list
    • complexity: O(1) for each element added, so O(N) to add N elements when the command is called with multiple arguments.
    • since: 1.0.0

    Parameters

    • Rest...args: [key: RedisKey, ...elements: (string | number | Buffer)[], callback: Callback<number>]

    Returns Promise<number>

  • Parameters

    • Rest...args: [key: RedisKey, ...elements: (string | number | Buffer)[]]

    Returns Promise<number>

  • Prepend an element to a list, only if the list exists

    • group: list
    • complexity: O(1) for each element added, so O(N) to add N elements when the command is called with multiple arguments.
    • since: 2.2.0

    Parameters

    • Rest...args: [key: RedisKey, ...elements: (string | number | Buffer)[], callback: Callback<number>]

    Returns Promise<number>

  • Parameters

    • Rest...args: [key: RedisKey, ...elements: (string | number | Buffer)[]]

    Returns Promise<number>

  • Get a range of elements from a list

    • group: list
    • complexity: O(S+N) where S is the distance of start offset from HEAD for small lists, from nearest end (HEAD or TAIL) for large lists; and N is the number of elements in the specified range.
    • since: 1.0.0

    Parameters

    • key: RedisKey
    • start: string | number
    • stop: string | number
    • Optionalcallback: Callback<string[]>

    Returns Promise<string[]>

  • Parameters

    • key: RedisKey
    • start: string | number
    • stop: string | number
    • Optionalcallback: Callback<Buffer[]>

    Returns Promise<Buffer[]>

  • Remove elements from a list

    • group: list
    • complexity: O(N+M) where N is the length of the list and M is the number of elements removed.
    • since: 1.0.0

    Parameters

    • key: RedisKey
    • count: string | number
    • element: string | number | Buffer
    • Optionalcallback: Callback<number>

    Returns Promise<number>

  • Set the value of an element in a list by its index

    • group: list
    • complexity: O(N) where N is the length of the list. Setting either the first or the last element of the list is O(1).
    • since: 1.0.0

    Parameters

    • key: RedisKey
    • index: string | number
    • element: string | number | Buffer
    • Optionalcallback: Callback<"OK">

    Returns Promise<"OK">

  • Trim a list to the specified range

    • group: list
    • complexity: O(N) where N is the number of elements to be removed by the operation.
    • since: 1.0.0

    Parameters

    • key: RedisKey
    • start: string | number
    • stop: string | number
    • Optionalcallback: Callback<"OK">

    Returns Promise<"OK">

  • Outputs memory problems report

    • group: server
    • complexity: O(1)
    • since: 4.0.0

    Parameters

    • subcommand: "DOCTOR"
    • Optionalcallback: Callback<string>

    Returns Promise<string>

  • Show helpful text about the different subcommands

    • group: server
    • complexity: O(1)
    • since: 4.0.0

    Parameters

    • subcommand: "HELP"
    • Optionalcallback: Callback<unknown[]>

    Returns Promise<unknown[]>

  • Show allocator internal stats

    • group: server
    • complexity: Depends on how much memory is allocated, could be slow
    • since: 4.0.0

    Parameters

    • subcommand: "MALLOC-STATS"
    • Optionalcallback: Callback<string>

    Returns Promise<string>

  • Ask the allocator to release memory

    • group: server
    • complexity: Depends on how much memory is allocated, could be slow
    • since: 4.0.0

    Parameters

    • subcommand: "PURGE"
    • Optionalcallback: Callback<"OK">

    Returns Promise<"OK">

  • Show memory usage details

    • group: server
    • complexity: O(1)
    • since: 4.0.0

    Parameters

    • subcommand: "STATS"
    • Optionalcallback: Callback<unknown[]>

    Returns Promise<unknown[]>

  • Estimate the memory usage of a key

    • group: server
    • complexity: O(N) where N is the number of samples.
    • since: 4.0.0

    Parameters

    • subcommand: "USAGE"
    • key: RedisKey
    • Optionalcallback: Callback<null | number>

    Returns Promise<null | number>

  • Parameters

    • subcommand: "USAGE"
    • key: RedisKey
    • countToken: "SAMPLES"
    • count: string | number
    • Optionalcallback: Callback<null | number>

    Returns Promise<null | number>

  • Get the values of all the given keys

    • group: string
    • complexity: O(N) where N is the number of keys to retrieve.
    • since: 1.0.0

    Parameters

    • Rest...args: [...keys: RedisKey[], callback: Callback<(null | string)[]>]

    Returns Promise<(null | string)[]>

  • Parameters

    • Rest...args: [keys: RedisKey[], callback: Callback<(null | string)[]>]

    Returns Promise<(null | string)[]>

  • Parameters

    • Rest...args: RedisKey[]

    Returns Promise<(null | string)[]>

  • Parameters

    • Rest...args: [keys: RedisKey[]]

    Returns Promise<(null | string)[]>

  • Parameters

    • Rest...args: [...keys: RedisKey[], callback: Callback<(null | Buffer)[]>]

    Returns Promise<(null | Buffer)[]>

  • Parameters

    • Rest...args: [keys: RedisKey[], callback: Callback<(null | Buffer)[]>]

    Returns Promise<(null | Buffer)[]>

  • Parameters

    • Rest...args: RedisKey[]

    Returns Promise<(null | Buffer)[]>

  • Parameters

    • Rest...args: [keys: RedisKey[]]

    Returns Promise<(null | Buffer)[]>

  • Atomically transfer a key from a Redis instance to another one.

    • group: generic
    • complexity: This command actually executes a DUMP+DEL in the source instance, and a RESTORE in the target instance. See the pages of these commands for time complexity. Also an O(N) data transfer between the two instances is performed.
    • since: 2.6.0

    Parameters

    • Rest...args: [host: string | Buffer, port: string | number, ...args: RedisValue[], callback: Callback<"OK">]

    Returns Promise<"OK">

  • Parameters

    • Rest...args: [host: string | Buffer, port: string | number, ...args: RedisValue[]]

    Returns Promise<"OK">

  • Show helpful text about the different subcommands

    • group: server
    • complexity: O(1)
    • since: 5.0.0

    Parameters

    • subcommand: "HELP"
    • Optionalcallback: Callback<unknown>

    Returns Promise<unknown>

  • List all modules loaded by the server

    • group: server
    • complexity: O(N) where N is the number of loaded modules.
    • since: 4.0.0

    Parameters

    • subcommand: "LIST"
    • Optionalcallback: Callback<unknown>

    Returns Promise<unknown>

  • Load a module

    • group: server
    • complexity: O(1)
    • since: 4.0.0

    Parameters

    • subcommand: "LOAD"
    • path: string | Buffer
    • Optionalcallback: Callback<unknown>

    Returns Promise<unknown>

  • Parameters

    • Rest...args: [subcommand: "LOAD", path: string | Buffer, ...args: (string | number | Buffer)[], callback: Callback<unknown>]

    Returns Promise<unknown>

  • Parameters

    • Rest...args: [subcommand: "LOAD", path: string | Buffer, ...args: (string | number | Buffer)[]]

    Returns Promise<unknown>

  • Load a module with extended parameters

    • group: server
    • complexity: O(1)
    • since: 7.0.0

    Parameters

    • subcommand: "LOADEX"
    • path: string | Buffer
    • Optionalcallback: Callback<unknown>

    Returns Promise<unknown>

  • Parameters

    • Rest...args: [subcommand: "LOADEX", path: string | Buffer, argsToken: "ARGS", ...args: (string | number | Buffer)[], callback: Callback<unknown>]

    Returns Promise<unknown>

  • Parameters

    • Rest...args: [subcommand: "LOADEX", path: string | Buffer, argsToken: "ARGS", ...args: (string | number | Buffer)[]]

    Returns Promise<unknown>

  • Parameters

    • Rest...args: [subcommand: "LOADEX", path: string | Buffer, configsToken: "CONFIG", ...configs: (string | number | Buffer)[], callback: Callback<unknown>]

    Returns Promise<unknown>

  • Parameters

    • Rest...args: [subcommand: "LOADEX", path: string | Buffer, configsToken: "CONFIG", ...configs: (string | number | Buffer)[]]

    Returns Promise<unknown>

  • Parameters

    • Rest...args: [subcommand: "LOADEX", path: string | Buffer, configsToken: "CONFIG", ...args: RedisValue[], callback: Callback<unknown>]

    Returns Promise<unknown>

  • Parameters

    • Rest...args: [subcommand: "LOADEX", path: string | Buffer, configsToken: "CONFIG", ...args: RedisValue[]]

    Returns Promise<unknown>

  • Unload a module

    • group: server
    • complexity: O(1)
    • since: 4.0.0

    Parameters

    • subcommand: "UNLOAD"
    • name: string | Buffer
    • Optionalcallback: Callback<unknown>

    Returns Promise<unknown>

  • Listen for all requests received by the server in real time.

    This command will create a new connection to Redis and send a MONITOR command via the new connection in order to avoid disturbing the current connection.

    Parameters

    • Optionalcallback: Callback<Redis>

      The callback function. If omit, a promise will be returned.

    Returns Promise<Redis>

    var redis = new Redis();
    redis.monitor(function (err, monitor) {
    // Entering monitoring mode.
    monitor.on('monitor', function (time, args, source, database) {
    console.log(time + ": " + util.inspect(args));
    });
    });

    // supports promise as well as other commands
    redis.monitor().then(function (monitor) {
    monitor.on('monitor', function (time, args, source, database) {
    console.log(time + ": " + util.inspect(args));
    });
    });
  • Move a key to another database

    • group: generic
    • complexity: O(1)
    • since: 1.0.0

    Parameters

    • key: RedisKey
    • db: string | number
    • Optionalcallback: Callback<number>

    Returns Promise<number>

  • Set multiple keys to multiple values

    • group: string
    • complexity: O(N) where N is the number of keys to set.
    • since: 1.0.1

    Parameters

    • object: object
    • Optionalcallback: Callback<"OK">

    Returns Promise<"OK">

  • Parameters

    • map: Map<string | number | Buffer, string | number | Buffer>
    • Optionalcallback: Callback<"OK">

    Returns Promise<"OK">

  • Parameters

    • Rest...args: [...keyValues: (number | RedisKey)[], callback: Callback<"OK">]

    Returns Promise<"OK">

  • Parameters

    • Rest...args: (number | RedisKey)[]

    Returns Promise<"OK">

  • Set multiple keys to multiple values, only if none of the keys exist

    • group: string
    • complexity: O(N) where N is the number of keys to set.
    • since: 1.0.1

    Parameters

    • object: object
    • Optionalcallback: Callback<"OK">

    Returns Promise<"OK">

  • Parameters

    • map: Map<string | number | Buffer, string | number | Buffer>
    • Optionalcallback: Callback<"OK">

    Returns Promise<"OK">

  • Parameters

    • Rest...args: [...keyValues: (number | RedisKey)[], callback: Callback<number>]

    Returns Promise<number>

  • Parameters

    • Rest...args: (number | RedisKey)[]

    Returns Promise<number>

  • Parameters

    • options: {
          pipeline: false;
      }
      • pipeline: false

    Returns Promise<"OK">

  • Returns ChainableCommander

  • Parameters

    • options: {
          pipeline: true;
      }
      • pipeline: true

    Returns ChainableCommander

  • Parameters

    • Optionalcommands: unknown[][]

    Returns ChainableCommander

  • Inspect the internal encoding of a Redis object

    • group: generic
    • complexity: O(1)
    • since: 2.2.3

    Parameters

    • subcommand: "ENCODING"
    • key: RedisKey
    • Optionalcallback: Callback<unknown>

    Returns Promise<unknown>

  • Get the logarithmic access frequency counter of a Redis object

    • group: generic
    • complexity: O(1)
    • since: 4.0.0

    Parameters

    • subcommand: "FREQ"
    • key: RedisKey
    • Optionalcallback: Callback<unknown>

    Returns Promise<unknown>

  • Show helpful text about the different subcommands

    • group: generic
    • complexity: O(1)
    • since: 6.2.0

    Parameters

    • subcommand: "HELP"
    • Optionalcallback: Callback<unknown>

    Returns Promise<unknown>

  • Get the time since a Redis object was last accessed

    • group: generic
    • complexity: O(1)
    • since: 2.2.3

    Parameters

    • subcommand: "IDLETIME"
    • key: RedisKey
    • Optionalcallback: Callback<unknown>

    Returns Promise<unknown>

  • Get the number of references to the value of the key

    • group: generic
    • complexity: O(1)
    • since: 2.2.3

    Parameters

    • subcommand: "REFCOUNT"
    • key: RedisKey
    • Optionalcallback: Callback<unknown>

    Returns Promise<unknown>

  • Alias for emitter.removeListener().

    Type Parameters

    • K

    Parameters

    • eventName: string | symbol
    • listener: ((...args: any[]) => void)
        • (...args): void
        • Parameters

          • Rest...args: any[]

          Returns void

    Returns this

    v10.0.0

  • Adds the listener function to the end of the listeners array for the event named eventName. No checks are made to see if the listener has already been added. Multiple calls passing the same combination of eventName and listener will result in the listener being added, and called, multiple times.

    server.on('connection', (stream) => {
    console.log('someone connected!');
    });

    Returns a reference to the EventEmitter, so that calls can be chained.

    By default, event listeners are invoked in the order they are added. The emitter.prependListener() method can be used as an alternative to add the event listener to the beginning of the listeners array.

    import { EventEmitter } from 'node:events';
    const myEE = new EventEmitter();
    myEE.on('foo', () => console.log('a'));
    myEE.prependListener('foo', () => console.log('b'));
    myEE.emit('foo');
    // Prints:
    // b
    // a

    Parameters

    • event: "message"
    • cb: ((channel: string, message: string) => void)
        • (channel, message): void
        • Parameters

          • channel: string
          • message: string

          Returns void

    Returns this

    v0.1.101

  • Adds the listener function to the end of the listeners array for the event named eventName. No checks are made to see if the listener has already been added. Multiple calls passing the same combination of eventName and listener will result in the listener being added, and called, multiple times.

    server.on('connection', (stream) => {
    console.log('someone connected!');
    });

    Returns a reference to the EventEmitter, so that calls can be chained.

    By default, event listeners are invoked in the order they are added. The emitter.prependListener() method can be used as an alternative to add the event listener to the beginning of the listeners array.

    import { EventEmitter } from 'node:events';
    const myEE = new EventEmitter();
    myEE.on('foo', () => console.log('a'));
    myEE.prependListener('foo', () => console.log('b'));
    myEE.emit('foo');
    // Prints:
    // b
    // a

    Parameters

    • event: "messageBuffer"
    • cb: ((channel: Buffer, message: Buffer) => void)
        • (channel, message): void
        • Parameters

          • channel: Buffer
          • message: Buffer

          Returns void

    Returns this

    v0.1.101

  • Adds the listener function to the end of the listeners array for the event named eventName. No checks are made to see if the listener has already been added. Multiple calls passing the same combination of eventName and listener will result in the listener being added, and called, multiple times.

    server.on('connection', (stream) => {
    console.log('someone connected!');
    });

    Returns a reference to the EventEmitter, so that calls can be chained.

    By default, event listeners are invoked in the order they are added. The emitter.prependListener() method can be used as an alternative to add the event listener to the beginning of the listeners array.

    import { EventEmitter } from 'node:events';
    const myEE = new EventEmitter();
    myEE.on('foo', () => console.log('a'));
    myEE.prependListener('foo', () => console.log('b'));
    myEE.emit('foo');
    // Prints:
    // b
    // a

    Parameters

    • event: "pmessage"
    • cb: ((pattern: string, channel: string, message: string) => void)
        • (pattern, channel, message): void
        • Parameters

          • pattern: string
          • channel: string
          • message: string

          Returns void

    Returns this

    v0.1.101

  • Adds the listener function to the end of the listeners array for the event named eventName. No checks are made to see if the listener has already been added. Multiple calls passing the same combination of eventName and listener will result in the listener being added, and called, multiple times.

    server.on('connection', (stream) => {
    console.log('someone connected!');
    });

    Returns a reference to the EventEmitter, so that calls can be chained.

    By default, event listeners are invoked in the order they are added. The emitter.prependListener() method can be used as an alternative to add the event listener to the beginning of the listeners array.

    import { EventEmitter } from 'node:events';
    const myEE = new EventEmitter();
    myEE.on('foo', () => console.log('a'));
    myEE.prependListener('foo', () => console.log('b'));
    myEE.emit('foo');
    // Prints:
    // b
    // a

    Parameters

    • event: "pmessageBuffer"
    • cb: ((pattern: string, channel: Buffer, message: Buffer) => void)
        • (pattern, channel, message): void
        • Parameters

          • pattern: string
          • channel: Buffer
          • message: Buffer

          Returns void

    Returns this

    v0.1.101

  • Adds the listener function to the end of the listeners array for the event named eventName. No checks are made to see if the listener has already been added. Multiple calls passing the same combination of eventName and listener will result in the listener being added, and called, multiple times.

    server.on('connection', (stream) => {
    console.log('someone connected!');
    });

    Returns a reference to the EventEmitter, so that calls can be chained.

    By default, event listeners are invoked in the order they are added. The emitter.prependListener() method can be used as an alternative to add the event listener to the beginning of the listeners array.

    import { EventEmitter } from 'node:events';
    const myEE = new EventEmitter();
    myEE.on('foo', () => console.log('a'));
    myEE.prependListener('foo', () => console.log('b'));
    myEE.emit('foo');
    // Prints:
    // b
    // a

    Parameters

    • event: "error"
    • cb: ((error: Error) => void)
        • (error): void
        • Parameters

          • error: Error

          Returns void

    Returns this

    v0.1.101

  • Adds the listener function to the end of the listeners array for the event named eventName. No checks are made to see if the listener has already been added. Multiple calls passing the same combination of eventName and listener will result in the listener being added, and called, multiple times.

    server.on('connection', (stream) => {
    console.log('someone connected!');
    });

    Returns a reference to the EventEmitter, so that calls can be chained.

    By default, event listeners are invoked in the order they are added. The emitter.prependListener() method can be used as an alternative to add the event listener to the beginning of the listeners array.

    import { EventEmitter } from 'node:events';
    const myEE = new EventEmitter();
    myEE.on('foo', () => console.log('a'));
    myEE.prependListener('foo', () => console.log('b'));
    myEE.emit('foo');
    // Prints:
    // b
    // a

    Parameters

    • event: RedisStatus
    • cb: (() => void)
        • (): void
        • Returns void

    Returns this

    v0.1.101

  • Adds the listener function to the end of the listeners array for the event named eventName. No checks are made to see if the listener has already been added. Multiple calls passing the same combination of eventName and listener will result in the listener being added, and called, multiple times.

    server.on('connection', (stream) => {
    console.log('someone connected!');
    });

    Returns a reference to the EventEmitter, so that calls can be chained.

    By default, event listeners are invoked in the order they are added. The emitter.prependListener() method can be used as an alternative to add the event listener to the beginning of the listeners array.

    import { EventEmitter } from 'node:events';
    const myEE = new EventEmitter();
    myEE.on('foo', () => console.log('a'));
    myEE.prependListener('foo', () => console.log('b'));
    myEE.emit('foo');
    // Prints:
    // b
    // a

    Parameters

    • event: string | symbol
    • listener: ((...args: any[]) => void)

      The callback function

        • (...args): void
        • Parameters

          • Rest...args: any[]

          Returns void

    Returns this

    v0.1.101

  • Adds a one-time listener function for the event named eventName. The next time eventName is triggered, this listener is removed and then invoked.

    server.once('connection', (stream) => {
    console.log('Ah, we have our first user!');
    });

    Returns a reference to the EventEmitter, so that calls can be chained.

    By default, event listeners are invoked in the order they are added. The emitter.prependOnceListener() method can be used as an alternative to add the event listener to the beginning of the listeners array.

    import { EventEmitter } from 'node:events';
    const myEE = new EventEmitter();
    myEE.once('foo', () => console.log('a'));
    myEE.prependOnceListener('foo', () => console.log('b'));
    myEE.emit('foo');
    // Prints:
    // b
    // a

    Parameters

    • event: "message"
    • cb: ((channel: string, message: string) => void)
        • (channel, message): void
        • Parameters

          • channel: string
          • message: string

          Returns void

    Returns this

    v0.3.0

  • Adds a one-time listener function for the event named eventName. The next time eventName is triggered, this listener is removed and then invoked.

    server.once('connection', (stream) => {
    console.log('Ah, we have our first user!');
    });

    Returns a reference to the EventEmitter, so that calls can be chained.

    By default, event listeners are invoked in the order they are added. The emitter.prependOnceListener() method can be used as an alternative to add the event listener to the beginning of the listeners array.

    import { EventEmitter } from 'node:events';
    const myEE = new EventEmitter();
    myEE.once('foo', () => console.log('a'));
    myEE.prependOnceListener('foo', () => console.log('b'));
    myEE.emit('foo');
    // Prints:
    // b
    // a

    Parameters

    • event: "messageBuffer"
    • cb: ((channel: Buffer, message: Buffer) => void)
        • (channel, message): void
        • Parameters

          • channel: Buffer
          • message: Buffer

          Returns void

    Returns this

    v0.3.0

  • Adds a one-time listener function for the event named eventName. The next time eventName is triggered, this listener is removed and then invoked.

    server.once('connection', (stream) => {
    console.log('Ah, we have our first user!');
    });

    Returns a reference to the EventEmitter, so that calls can be chained.

    By default, event listeners are invoked in the order they are added. The emitter.prependOnceListener() method can be used as an alternative to add the event listener to the beginning of the listeners array.

    import { EventEmitter } from 'node:events';
    const myEE = new EventEmitter();
    myEE.once('foo', () => console.log('a'));
    myEE.prependOnceListener('foo', () => console.log('b'));
    myEE.emit('foo');
    // Prints:
    // b
    // a

    Parameters

    • event: "pmessage"
    • cb: ((pattern: string, channel: string, message: string) => void)
        • (pattern, channel, message): void
        • Parameters

          • pattern: string
          • channel: string
          • message: string

          Returns void

    Returns this

    v0.3.0

  • Adds a one-time listener function for the event named eventName. The next time eventName is triggered, this listener is removed and then invoked.

    server.once('connection', (stream) => {
    console.log('Ah, we have our first user!');
    });

    Returns a reference to the EventEmitter, so that calls can be chained.

    By default, event listeners are invoked in the order they are added. The emitter.prependOnceListener() method can be used as an alternative to add the event listener to the beginning of the listeners array.

    import { EventEmitter } from 'node:events';
    const myEE = new EventEmitter();
    myEE.once('foo', () => console.log('a'));
    myEE.prependOnceListener('foo', () => console.log('b'));
    myEE.emit('foo');
    // Prints:
    // b
    // a

    Parameters

    • event: "pmessageBuffer"
    • cb: ((pattern: string, channel: Buffer, message: Buffer) => void)
        • (pattern, channel, message): void
        • Parameters

          • pattern: string
          • channel: Buffer
          • message: Buffer

          Returns void

    Returns this

    v0.3.0

  • Adds a one-time listener function for the event named eventName. The next time eventName is triggered, this listener is removed and then invoked.

    server.once('connection', (stream) => {
    console.log('Ah, we have our first user!');
    });

    Returns a reference to the EventEmitter, so that calls can be chained.

    By default, event listeners are invoked in the order they are added. The emitter.prependOnceListener() method can be used as an alternative to add the event listener to the beginning of the listeners array.

    import { EventEmitter } from 'node:events';
    const myEE = new EventEmitter();
    myEE.once('foo', () => console.log('a'));
    myEE.prependOnceListener('foo', () => console.log('b'));
    myEE.emit('foo');
    // Prints:
    // b
    // a

    Parameters

    • event: "error"
    • cb: ((error: Error) => void)
        • (error): void
        • Parameters

          • error: Error

          Returns void

    Returns this

    v0.3.0

  • Adds a one-time listener function for the event named eventName. The next time eventName is triggered, this listener is removed and then invoked.

    server.once('connection', (stream) => {
    console.log('Ah, we have our first user!');
    });

    Returns a reference to the EventEmitter, so that calls can be chained.

    By default, event listeners are invoked in the order they are added. The emitter.prependOnceListener() method can be used as an alternative to add the event listener to the beginning of the listeners array.

    import { EventEmitter } from 'node:events';
    const myEE = new EventEmitter();
    myEE.once('foo', () => console.log('a'));
    myEE.prependOnceListener('foo', () => console.log('b'));
    myEE.emit('foo');
    // Prints:
    // b
    // a

    Parameters

    • event: RedisStatus
    • cb: (() => void)
        • (): void
        • Returns void

    Returns this

    v0.3.0

  • Adds a one-time listener function for the event named eventName. The next time eventName is triggered, this listener is removed and then invoked.

    server.once('connection', (stream) => {
    console.log('Ah, we have our first user!');
    });

    Returns a reference to the EventEmitter, so that calls can be chained.

    By default, event listeners are invoked in the order they are added. The emitter.prependOnceListener() method can be used as an alternative to add the event listener to the beginning of the listeners array.

    import { EventEmitter } from 'node:events';
    const myEE = new EventEmitter();
    myEE.once('foo', () => console.log('a'));
    myEE.prependOnceListener('foo', () => console.log('b'));
    myEE.emit('foo');
    // Prints:
    // b
    // a

    Parameters

    • event: string | symbol
    • listener: ((...args: any[]) => void)

      The callback function

        • (...args): void
        • Parameters

          • Rest...args: any[]

          Returns void

    Returns this

    v0.3.0

  • Remove the expiration from a key

    • group: generic
    • complexity: O(1)
    • since: 2.2.0

    Parameters

    • key: RedisKey
    • Optionalcallback: Callback<number>

    Returns Promise<number>

  • Set a key's time to live in milliseconds

    • group: generic
    • complexity: O(1)
    • since: 2.6.0

    Parameters

    • key: RedisKey
    • milliseconds: string | number
    • Optionalcallback: Callback<number>

    Returns Promise<number>

  • Parameters

    • key: RedisKey
    • milliseconds: string | number
    • nx: "NX"
    • Optionalcallback: Callback<number>

    Returns Promise<number>

  • Parameters

    • key: RedisKey
    • milliseconds: string | number
    • xx: "XX"
    • Optionalcallback: Callback<number>

    Returns Promise<number>

  • Parameters

    • key: RedisKey
    • milliseconds: string | number
    • gt: "GT"
    • Optionalcallback: Callback<number>

    Returns Promise<number>

  • Parameters

    • key: RedisKey
    • milliseconds: string | number
    • lt: "LT"
    • Optionalcallback: Callback<number>

    Returns Promise<number>

  • Set the expiration for a key as a UNIX timestamp specified in milliseconds

    • group: generic
    • complexity: O(1)
    • since: 2.6.0

    Parameters

    • key: RedisKey
    • unixTimeMilliseconds: string | number
    • Optionalcallback: Callback<number>

    Returns Promise<number>

  • Parameters

    • key: RedisKey
    • unixTimeMilliseconds: string | number
    • nx: "NX"
    • Optionalcallback: Callback<number>

    Returns Promise<number>

  • Parameters

    • key: RedisKey
    • unixTimeMilliseconds: string | number
    • xx: "XX"
    • Optionalcallback: Callback<number>

    Returns Promise<number>

  • Parameters

    • key: RedisKey
    • unixTimeMilliseconds: string | number
    • gt: "GT"
    • Optionalcallback: Callback<number>

    Returns Promise<number>

  • Parameters

    • key: RedisKey
    • unixTimeMilliseconds: string | number
    • lt: "LT"
    • Optionalcallback: Callback<number>

    Returns Promise<number>

  • Get the expiration Unix timestamp for a key in milliseconds

    • group: generic
    • complexity: O(1)
    • since: 7.0.0

    Parameters

    • key: RedisKey
    • Optionalcallback: Callback<number>

    Returns Promise<number>

  • Adds the specified elements to the specified HyperLogLog.

    • group: hyperloglog
    • complexity: O(1) to add every element.
    • since: 2.8.9

    Parameters

    • key: RedisKey
    • Optionalcallback: Callback<number>

    Returns Promise<number>

  • Parameters

    • Rest...args: [key: RedisKey, ...elements: (string | number | Buffer)[], callback: Callback<number>]

    Returns Promise<number>

  • Parameters

    • Rest...args: [key: RedisKey, ...elements: (string | number | Buffer)[]]

    Returns Promise<number>

  • Return the approximated cardinality of the set(s) observed by the HyperLogLog at key(s).

    • group: hyperloglog
    • complexity: O(1) with a very small average constant time when called with a single key. O(N) with N being the number of keys, and much bigger constant times, when called with multiple keys.
    • since: 2.8.9

    Parameters

    • Rest...args: [...keys: RedisKey[], callback: Callback<number>]

    Returns Promise<number>

  • Parameters

    • Rest...args: [keys: RedisKey[], callback: Callback<number>]

    Returns Promise<number>

  • Parameters

    • Rest...args: RedisKey[]

    Returns Promise<number>

  • Parameters

    • Rest...args: [keys: RedisKey[]]

    Returns Promise<number>

  • Internal commands for debugging HyperLogLog values

    • group: hyperloglog
    • complexity: N/A
    • since: 2.8.9

    Parameters

    • subcommand: string | Buffer
    • key: RedisKey
    • Optionalcallback: Callback<unknown>

    Returns Promise<unknown>

  • Merge N different HyperLogLogs into a single one.

    • group: hyperloglog
    • complexity: O(N) to merge N HyperLogLogs, but with high constant times.
    • since: 2.8.9

    Parameters

    • Rest...args: [destkey: RedisKey, ...sourcekeys: RedisKey[], callback: Callback<"OK">]

    Returns Promise<"OK">

  • Parameters

    • Rest...args: [destkey: RedisKey, sourcekeys: RedisKey[], callback: Callback<"OK">]

    Returns Promise<"OK">

  • Parameters

    • Rest...args: [destkey: RedisKey, ...sourcekeys: RedisKey[]]

    Returns Promise<"OK">

  • Parameters

    • Rest...args: [destkey: RedisKey, sourcekeys: RedisKey[]]

    Returns Promise<"OK">

  • An internal command for testing HyperLogLog values

    • group: hyperloglog
    • complexity: N/A
    • since: 2.8.9

    Parameters

    • Optionalcallback: Callback<unknown>

    Returns Promise<unknown>

  • Ping the server

    • group: connection
    • complexity: O(1)
    • since: 1.0.0

    Parameters

    • Optionalcallback: Callback<"PONG">

    Returns Promise<"PONG">

  • Parameters

    • message: string | Buffer
    • Optionalcallback: Callback<string>

    Returns Promise<string>

  • Parameters

    • message: string | Buffer
    • Optionalcallback: Callback<Buffer>

    Returns Promise<Buffer>

  • Parameters

    • Optionalcommands: unknown[][]

    Returns ChainableCommander

  • Adds the listener function to the beginning of the listeners array for the event named eventName. No checks are made to see if the listener has already been added. Multiple calls passing the same combination of eventName and listener will result in the listener being added, and called, multiple times.

    server.prependListener('connection', (stream) => {
    console.log('someone connected!');
    });

    Returns a reference to the EventEmitter, so that calls can be chained.

    Type Parameters

    • K

    Parameters

    • eventName: string | symbol

      The name of the event.

    • listener: ((...args: any[]) => void)

      The callback function

        • (...args): void
        • Parameters

          • Rest...args: any[]

          Returns void

    Returns this

    v6.0.0

  • Adds a one-timelistener function for the event named eventName to the beginning of the listeners array. The next time eventName is triggered, this listener is removed, and then invoked.

    server.prependOnceListener('connection', (stream) => {
    console.log('Ah, we have our first user!');
    });

    Returns a reference to the EventEmitter, so that calls can be chained.

    Type Parameters

    • K

    Parameters

    • eventName: string | symbol

      The name of the event.

    • listener: ((...args: any[]) => void)

      The callback function

        • (...args): void
        • Parameters

          • Rest...args: any[]

          Returns void

    Returns this

    v6.0.0

  • Set the value and expiration in milliseconds of a key

    • group: string
    • complexity: O(1)
    • since: 2.6.0

    Parameters

    • key: RedisKey
    • milliseconds: string | number
    • value: string | number | Buffer
    • Optionalcallback: Callback<unknown>

    Returns Promise<unknown>

  • Listen for messages published to channels matching the given patterns

    • group: pubsub
    • complexity: O(N) where N is the number of patterns the client is already subscribed to.
    • since: 2.0.0

    Parameters

    • Rest...args: [...patterns: string[], callback: Callback<unknown>]

    Returns Promise<unknown>

  • Parameters

    • Rest...args: string[]

    Returns Promise<unknown>

  • Internal command used for replication

    • group: server
    • complexity: undefined
    • since: 2.8.0

    Parameters

    • replicationid: string | number | Buffer
    • offset: string | number
    • Optionalcallback: Callback<unknown>

    Returns Promise<unknown>

  • Get the time to live for a key in milliseconds

    • group: generic
    • complexity: O(1)
    • since: 2.6.0

    Parameters

    • key: RedisKey
    • Optionalcallback: Callback<number>

    Returns Promise<number>

  • Post a message to a channel

    • group: pubsub
    • complexity: O(N+M) where N is the number of clients subscribed to the receiving channel and M is the total number of subscribed patterns (by any client).
    • since: 2.0.0

    Parameters

    • channel: string | Buffer
    • message: string | Buffer
    • Optionalcallback: Callback<number>

    Returns Promise<number>

  • List active channels

    • group: pubsub
    • complexity: O(N) where N is the number of active channels, and assuming constant time pattern matching (relatively short channels and patterns)
    • since: 2.8.0

    Parameters

    • subcommand: "CHANNELS"
    • Optionalcallback: Callback<unknown[]>

    Returns Promise<unknown[]>

  • Parameters

    • subcommand: "CHANNELS"
    • pattern: string
    • Optionalcallback: Callback<unknown[]>

    Returns Promise<unknown[]>

  • Show helpful text about the different subcommands

    • group: pubsub
    • complexity: O(1)
    • since: 6.2.0

    Parameters

    • subcommand: "HELP"
    • Optionalcallback: Callback<unknown[]>

    Returns Promise<unknown[]>

  • Get the count of unique patterns pattern subscriptions

    • group: pubsub
    • complexity: O(1)
    • since: 2.8.0

    Parameters

    • subcommand: "NUMPAT"
    • Optionalcallback: Callback<unknown[]>

    Returns Promise<unknown[]>

  • Get the count of subscribers for channels

    • group: pubsub
    • complexity: O(N) for the NUMSUB subcommand, where N is the number of requested channels
    • since: 2.8.0

    Parameters

    • subcommand: "NUMSUB"
    • Optionalcallback: Callback<unknown[]>

    Returns Promise<unknown[]>

  • Parameters

    • Rest...args: [subcommand: "NUMSUB", ...channels: (string | Buffer)[], callback: Callback<unknown[]>]

    Returns Promise<unknown[]>

  • Parameters

    • Rest...args: [subcommand: "NUMSUB", ...channels: (string | Buffer)[]]

    Returns Promise<unknown[]>

  • List active shard channels

    • group: pubsub
    • complexity: O(N) where N is the number of active shard channels, and assuming constant time pattern matching (relatively short shard channels).
    • since: 7.0.0

    Parameters

    • subcommand: "SHARDCHANNELS"
    • Optionalcallback: Callback<unknown[]>

    Returns Promise<unknown[]>

  • Parameters

    • subcommand: "SHARDCHANNELS"
    • pattern: string
    • Optionalcallback: Callback<unknown[]>

    Returns Promise<unknown[]>

  • Get the count of subscribers for shard channels

    • group: pubsub
    • complexity: O(N) for the SHARDNUMSUB subcommand, where N is the number of requested shard channels
    • since: 7.0.0

    Parameters

    • subcommand: "SHARDNUMSUB"
    • Optionalcallback: Callback<unknown[]>

    Returns Promise<unknown[]>

  • Parameters

    • Rest...args: [subcommand: "SHARDNUMSUB", ...shardchannels: (string | Buffer)[], callback: Callback<unknown[]>]

    Returns Promise<unknown[]>

  • Parameters

    • Rest...args: [subcommand: "SHARDNUMSUB", ...shardchannels: (string | Buffer)[]]

    Returns Promise<unknown[]>

  • Stop listening for messages posted to channels matching the given patterns

    • group: pubsub
    • complexity: O(N+M) where N is the number of patterns the client is already subscribed and M is the number of total patterns subscribed in the system (by any client).
    • since: 2.0.0

    Parameters

    • Optionalcallback: Callback<unknown>

    Returns Promise<unknown>

  • Parameters

    • Rest...args: [...patterns: string[], callback: Callback<unknown>]

    Returns Promise<unknown>

  • Parameters

    • Rest...args: string[]

    Returns Promise<unknown>

  • Close the connection

    • group: connection
    • complexity: O(1)
    • since: 1.0.0

    Parameters

    • Optionalcallback: Callback<"OK">

    Returns Promise<"OK">

  • Return a random key from the keyspace

    • group: generic
    • complexity: O(1)
    • since: 1.0.0

    Parameters

    • Optionalcallback: Callback<null | string>

    Returns Promise<null | string>

  • Parameters

    • Optionalcallback: Callback<null | Buffer>

    Returns Promise<null | Buffer>

  • Returns a copy of the array of listeners for the event named eventName, including any wrappers (such as those created by .once()).

    import { EventEmitter } from 'node:events';
    const emitter = new EventEmitter();
    emitter.once('log', () => console.log('log once'));

    // Returns a new Array with a function `onceWrapper` which has a property
    // `listener` which contains the original listener bound above
    const listeners = emitter.rawListeners('log');
    const logFnWrapper = listeners[0];

    // Logs "log once" to the console and does not unbind the `once` event
    logFnWrapper.listener();

    // Logs "log once" to the console and removes the listener
    logFnWrapper();

    emitter.on('log', () => console.log('log persistently'));
    // Will return a new Array with a single function bound by `.on()` above
    const newListeners = emitter.rawListeners('log');

    // Logs "log persistently" twice
    newListeners[0]();
    emitter.emit('log');

    Type Parameters

    • K

    Parameters

    • eventName: string | symbol

    Returns Function[]

    v9.4.0

  • Enables read queries for a connection to a cluster replica node

    • group: cluster
    • complexity: O(1)
    • since: 3.0.0

    Parameters

    • Optionalcallback: Callback<"OK">

    Returns Promise<"OK">

  • Disables read queries for a connection to a cluster replica node

    • group: cluster
    • complexity: O(1)
    • since: 3.0.0

    Parameters

    • Optionalcallback: Callback<"OK">

    Returns Promise<"OK">

  • Removes all listeners, or those of the specified eventName.

    It is bad practice to remove listeners added elsewhere in the code, particularly when the EventEmitter instance was created by some other component or module (e.g. sockets or file streams).

    Returns a reference to the EventEmitter, so that calls can be chained.

    Parameters

    • OptionaleventName: string | symbol

    Returns this

    v0.1.26

  • Removes the specified listener from the listener array for the event named eventName.

    const callback = (stream) => {
    console.log('someone connected!');
    };
    server.on('connection', callback);
    // ...
    server.removeListener('connection', callback);

    removeListener() will remove, at most, one instance of a listener from the listener array. If any single listener has been added multiple times to the listener array for the specified eventName, then removeListener() must be called multiple times to remove each instance.

    Once an event is emitted, all listeners attached to it at the time of emitting are called in order. This implies that any removeListener() or removeAllListeners() calls after emitting and before the last listener finishes execution will not remove them fromemit() in progress. Subsequent events behave as expected.

    import { EventEmitter } from 'node:events';
    class MyEmitter extends EventEmitter {}
    const myEmitter = new MyEmitter();

    const callbackA = () => {
    console.log('A');
    myEmitter.removeListener('event', callbackB);
    };

    const callbackB = () => {
    console.log('B');
    };

    myEmitter.on('event', callbackA);

    myEmitter.on('event', callbackB);

    // callbackA removes listener callbackB but it will still be called.
    // Internal listener array at time of emit [callbackA, callbackB]
    myEmitter.emit('event');
    // Prints:
    // A
    // B

    // callbackB is now removed.
    // Internal listener array [callbackA]
    myEmitter.emit('event');
    // Prints:
    // A

    Because listeners are managed using an internal array, calling this will change the position indices of any listener registered after the listener being removed. This will not impact the order in which listeners are called, but it means that any copies of the listener array as returned by the emitter.listeners() method will need to be recreated.

    When a single function has been added as a handler multiple times for a single event (as in the example below), removeListener() will remove the most recently added instance. In the example the once('ping') listener is removed:

    import { EventEmitter } from 'node:events';
    const ee = new EventEmitter();

    function pong() {
    console.log('pong');
    }

    ee.on('ping', pong);
    ee.once('ping', pong);
    ee.removeListener('ping', pong);

    ee.emit('ping');
    ee.emit('ping');

    Returns a reference to the EventEmitter, so that calls can be chained.

    Type Parameters

    • K

    Parameters

    • eventName: string | symbol
    • listener: ((...args: any[]) => void)
        • (...args): void
        • Parameters

          • Rest...args: any[]

          Returns void

    Returns this

    v0.1.26

  • Rename a key

    • group: generic
    • complexity: O(1)
    • since: 1.0.0

    Parameters

    • key: RedisKey
    • newkey: RedisKey
    • Optionalcallback: Callback<"OK">

    Returns Promise<"OK">

  • Rename a key, only if the new key does not exist

    • group: generic
    • complexity: O(1)
    • since: 1.0.0

    Parameters

    • key: RedisKey
    • newkey: RedisKey
    • Optionalcallback: Callback<number>

    Returns Promise<number>

  • An internal command for configuring the replication stream

    • group: server
    • complexity: O(1)
    • since: 3.0.0

    Parameters

    • Optionalcallback: Callback<unknown>

    Returns Promise<unknown>

  • Make the server a replica of another instance, or promote it as master.

    • group: server
    • complexity: O(1)
    • since: 5.0.0

    Parameters

    • host: string | Buffer
    • port: string | number
    • Optionalcallback: Callback<"OK">

    Returns Promise<"OK">

  • Reset the connection

    • group: connection
    • complexity: O(1)
    • since: 6.2.0

    Parameters

    • Optionalcallback: Callback<"OK">

    Returns Promise<"OK">

  • Create a key using the provided serialized value, previously obtained using DUMP.

    • group: generic
    • complexity: O(1) to create the new key and additional O(NM) to reconstruct the serialized value, where N is the number of Redis objects composing the value and M their average size. For small string values the time complexity is thus O(1)+O(1M) where M is small, so simply O(1). However for sorted set values the complexity is O(NMlog(N)) because inserting values into sorted sets is O(log(N)).
    • since: 2.6.0

    Parameters

    • key: RedisKey
    • ttl: string | number
    • serializedValue: string | number | Buffer
    • Optionalcallback: Callback<"OK">

    Returns Promise<"OK">

  • Parameters

    • key: RedisKey
    • ttl: string | number
    • serializedValue: string | number | Buffer
    • frequencyToken: "FREQ"
    • frequency: string | number
    • Optionalcallback: Callback<"OK">

    Returns Promise<"OK">

  • Parameters

    • key: RedisKey
    • ttl: string | number
    • serializedValue: string | number | Buffer
    • secondsToken: "IDLETIME"
    • seconds: string | number
    • Optionalcallback: Callback<"OK">

    Returns Promise<"OK">

  • Parameters

    • key: RedisKey
    • ttl: string | number
    • serializedValue: string | number | Buffer
    • secondsToken: "IDLETIME"
    • seconds: string | number
    • frequencyToken: "FREQ"
    • frequency: string | number
    • Optionalcallback: Callback<"OK">

    Returns Promise<"OK">

  • Parameters

    • key: RedisKey
    • ttl: string | number
    • serializedValue: string | number | Buffer
    • absttl: "ABSTTL"
    • Optionalcallback: Callback<"OK">

    Returns Promise<"OK">

  • Parameters

    • key: RedisKey
    • ttl: string | number
    • serializedValue: string | number | Buffer
    • absttl: "ABSTTL"
    • frequencyToken: "FREQ"
    • frequency: string | number
    • Optionalcallback: Callback<"OK">

    Returns Promise<"OK">

  • Parameters

    • key: RedisKey
    • ttl: string | number
    • serializedValue: string | number | Buffer
    • absttl: "ABSTTL"
    • secondsToken: "IDLETIME"
    • seconds: string | number
    • Optionalcallback: Callback<"OK">

    Returns Promise<"OK">

  • Parameters

    • key: RedisKey
    • ttl: string | number
    • serializedValue: string | number | Buffer
    • absttl: "ABSTTL"
    • secondsToken: "IDLETIME"
    • seconds: string | number
    • frequencyToken: "FREQ"
    • frequency: string | number
    • Optionalcallback: Callback<"OK">

    Returns Promise<"OK">

  • Parameters

    • key: RedisKey
    • ttl: string | number
    • serializedValue: string | number | Buffer
    • replace: "REPLACE"
    • Optionalcallback: Callback<"OK">

    Returns Promise<"OK">

  • Parameters

    • key: RedisKey
    • ttl: string | number
    • serializedValue: string | number | Buffer
    • replace: "REPLACE"
    • frequencyToken: "FREQ"
    • frequency: string | number
    • Optionalcallback: Callback<"OK">

    Returns Promise<"OK">

  • Parameters

    • key: RedisKey
    • ttl: string | number
    • serializedValue: string | number | Buffer
    • replace: "REPLACE"
    • secondsToken: "IDLETIME"
    • seconds: string | number
    • Optionalcallback: Callback<"OK">

    Returns Promise<"OK">

  • Parameters

    • key: RedisKey
    • ttl: string | number
    • serializedValue: string | number | Buffer
    • replace: "REPLACE"
    • secondsToken: "IDLETIME"
    • seconds: string | number
    • frequencyToken: "FREQ"
    • frequency: string | number
    • Optionalcallback: Callback<"OK">

    Returns Promise<"OK">

  • Parameters

    • key: RedisKey
    • ttl: string | number
    • serializedValue: string | number | Buffer
    • replace: "REPLACE"
    • absttl: "ABSTTL"
    • Optionalcallback: Callback<"OK">

    Returns Promise<"OK">

  • Parameters

    • key: RedisKey
    • ttl: string | number
    • serializedValue: string | number | Buffer
    • replace: "REPLACE"
    • absttl: "ABSTTL"
    • frequencyToken: "FREQ"
    • frequency: string | number
    • Optionalcallback: Callback<"OK">

    Returns Promise<"OK">

  • Parameters

    • key: RedisKey
    • ttl: string | number
    • serializedValue: string | number | Buffer
    • replace: "REPLACE"
    • absttl: "ABSTTL"
    • secondsToken: "IDLETIME"
    • seconds: string | number
    • Optionalcallback: Callback<"OK">

    Returns Promise<"OK">

  • Parameters

    • key: RedisKey
    • ttl: string | number
    • serializedValue: string | number | Buffer
    • replace: "REPLACE"
    • absttl: "ABSTTL"
    • secondsToken: "IDLETIME"
    • seconds: string | number
    • frequencyToken: "FREQ"
    • frequency: string | number
    • Optionalcallback: Callback<"OK">

    Returns Promise<"OK">

  • An internal command for migrating keys in a cluster

    • group: server
    • complexity: O(1) to create the new key and additional O(NM) to reconstruct the serialized value, where N is the number of Redis objects composing the value and M their average size. For small string values the time complexity is thus O(1)+O(1M) where M is small, so simply O(1). However for sorted set values the complexity is O(NMlog(N)) because inserting values into sorted sets is O(log(N)).
    • since: 3.0.0

    Parameters

    • key: RedisKey
    • ttl: string | number
    • serializedValue: string | number | Buffer
    • Optionalcallback: Callback<unknown>

    Returns Promise<unknown>

  • Parameters

    • key: RedisKey
    • ttl: string | number
    • serializedValue: string | number | Buffer
    • frequencyToken: "FREQ"
    • frequency: string | number
    • Optionalcallback: Callback<unknown>

    Returns Promise<unknown>

  • Parameters

    • key: RedisKey
    • ttl: string | number
    • serializedValue: string | number | Buffer
    • secondsToken: "IDLETIME"
    • seconds: string | number
    • Optionalcallback: Callback<unknown>

    Returns Promise<unknown>

  • Parameters

    • key: RedisKey
    • ttl: string | number
    • serializedValue: string | number | Buffer
    • secondsToken: "IDLETIME"
    • seconds: string | number
    • frequencyToken: "FREQ"
    • frequency: string | number
    • Optionalcallback: Callback<unknown>

    Returns Promise<unknown>

  • Parameters

    • key: RedisKey
    • ttl: string | number
    • serializedValue: string | number | Buffer
    • absttl: "ABSTTL"
    • Optionalcallback: Callback<unknown>

    Returns Promise<unknown>

  • Parameters

    • key: RedisKey
    • ttl: string | number
    • serializedValue: string | number | Buffer
    • absttl: "ABSTTL"
    • frequencyToken: "FREQ"
    • frequency: string | number
    • Optionalcallback: Callback<unknown>

    Returns Promise<unknown>

  • Parameters

    • key: RedisKey
    • ttl: string | number
    • serializedValue: string | number | Buffer
    • absttl: "ABSTTL"
    • secondsToken: "IDLETIME"
    • seconds: string | number
    • Optionalcallback: Callback<unknown>

    Returns Promise<unknown>

  • Parameters

    • key: RedisKey
    • ttl: string | number
    • serializedValue: string | number | Buffer
    • absttl: "ABSTTL"
    • secondsToken: "IDLETIME"
    • seconds: string | number
    • frequencyToken: "FREQ"
    • frequency: string | number
    • Optionalcallback: Callback<unknown>

    Returns Promise<unknown>

  • Parameters

    • key: RedisKey
    • ttl: string | number
    • serializedValue: string | number | Buffer
    • replace: "REPLACE"
    • Optionalcallback: Callback<unknown>

    Returns Promise<unknown>

  • Parameters

    • key: RedisKey
    • ttl: string | number
    • serializedValue: string | number | Buffer
    • replace: "REPLACE"
    • frequencyToken: "FREQ"
    • frequency: string | number
    • Optionalcallback: Callback<unknown>

    Returns Promise<unknown>

  • Parameters

    • key: RedisKey
    • ttl: string | number
    • serializedValue: string | number | Buffer
    • replace: "REPLACE"
    • secondsToken: "IDLETIME"
    • seconds: string | number
    • Optionalcallback: Callback<unknown>

    Returns Promise<unknown>

  • Parameters

    • key: RedisKey
    • ttl: string | number
    • serializedValue: string | number | Buffer
    • replace: "REPLACE"
    • secondsToken: "IDLETIME"
    • seconds: string | number
    • frequencyToken: "FREQ"
    • frequency: string | number
    • Optionalcallback: Callback<unknown>

    Returns Promise<unknown>

  • Parameters

    • key: RedisKey
    • ttl: string | number
    • serializedValue: string | number | Buffer
    • replace: "REPLACE"
    • absttl: "ABSTTL"
    • Optionalcallback: Callback<unknown>

    Returns Promise<unknown>

  • Parameters

    • key: RedisKey
    • ttl: string | number
    • serializedValue: string | number | Buffer
    • replace: "REPLACE"
    • absttl: "ABSTTL"
    • frequencyToken: "FREQ"
    • frequency: string | number
    • Optionalcallback: Callback<unknown>

    Returns Promise<unknown>

  • Parameters

    • key: RedisKey
    • ttl: string | number
    • serializedValue: string | number | Buffer
    • replace: "REPLACE"
    • absttl: "ABSTTL"
    • secondsToken: "IDLETIME"
    • seconds: string | number
    • Optionalcallback: Callback<unknown>

    Returns Promise<unknown>

  • Parameters

    • key: RedisKey
    • ttl: string | number
    • serializedValue: string | number | Buffer
    • replace: "REPLACE"
    • absttl: "ABSTTL"
    • secondsToken: "IDLETIME"
    • seconds: string | number
    • frequencyToken: "FREQ"
    • frequency: string | number
    • Optionalcallback: Callback<unknown>

    Returns Promise<unknown>

  • Return the role of the instance in the context of replication

    • group: server
    • complexity: O(1)
    • since: 2.8.12

    Parameters

    • Optionalcallback: Callback<unknown[]>

    Returns Promise<unknown[]>

  • Remove and get the last elements in a list

    • group: list
    • complexity: O(N) where N is the number of elements returned
    • since: 1.0.0

    Parameters

    • key: RedisKey
    • Optionalcallback: Callback<null | string>

    Returns Promise<null | string>

  • Parameters

    • key: RedisKey
    • count: string | number
    • Optionalcallback: Callback<null | string[]>

    Returns Promise<null | string[]>

  • Parameters

    • key: RedisKey
    • Optionalcallback: Callback<null | Buffer>

    Returns Promise<null | Buffer>

  • Parameters

    • key: RedisKey
    • count: string | number
    • Optionalcallback: Callback<null | Buffer[]>

    Returns Promise<null | Buffer[]>

  • Remove the last element in a list, prepend it to another list and return it

    • group: list
    • complexity: O(1)
    • since: 1.2.0

    Parameters

    • source: RedisKey
    • destination: RedisKey
    • Optionalcallback: Callback<string>

    Returns Promise<string>

  • Parameters

    • source: RedisKey
    • destination: RedisKey
    • Optionalcallback: Callback<Buffer>

    Returns Promise<Buffer>

  • Append one or multiple elements to a list

    • group: list
    • complexity: O(1) for each element added, so O(N) to add N elements when the command is called with multiple arguments.
    • since: 1.0.0

    Parameters

    • Rest...args: [key: RedisKey, ...elements: (string | number | Buffer)[], callback: Callback<number>]

    Returns Promise<number>

  • Parameters

    • Rest...args: [key: RedisKey, ...elements: (string | number | Buffer)[]]

    Returns Promise<number>

  • Append an element to a list, only if the list exists

    • group: list
    • complexity: O(1) for each element added, so O(N) to add N elements when the command is called with multiple arguments.
    • since: 2.2.0

    Parameters

    • Rest...args: [key: RedisKey, ...elements: (string | number | Buffer)[], callback: Callback<number>]

    Returns Promise<number>

  • Parameters

    • Rest...args: [key: RedisKey, ...elements: (string | number | Buffer)[]]

    Returns Promise<number>

  • Add one or more members to a set

    • group: set
    • complexity: O(1) for each element added, so O(N) to add N elements when the command is called with multiple arguments.
    • since: 1.0.0

    Parameters

    • Rest...args: [key: RedisKey, ...members: (string | number | Buffer)[], callback: Callback<number>]

    Returns Promise<number>

  • Parameters

    • Rest...args: [key: RedisKey, members: (string | number | Buffer)[], callback: Callback<number>]

    Returns Promise<number>

  • Parameters

    • Rest...args: [key: RedisKey, ...members: (string | number | Buffer)[]]

    Returns Promise<number>

  • Parameters

    • Rest...args: [key: RedisKey, members: (string | number | Buffer)[]]

    Returns Promise<number>

  • Synchronously save the dataset to disk

    • group: server
    • complexity: O(N) where N is the total number of keys in all databases
    • since: 1.0.0

    Parameters

    • Optionalcallback: Callback<"OK">

    Returns Promise<"OK">

  • Incrementally iterate the keys space

    • group: generic
    • complexity: O(1) for every call. O(N) for a complete iteration, including enough command calls for the cursor to return back to 0. N is the number of elements inside the collection.
    • since: 2.8.0

    Parameters

    • cursor: string | number
    • Optionalcallback: Callback<[cursor: string, elements: string[]]>

    Returns Promise<[cursor: string, elements: string[]]>

  • Parameters

    • cursor: string | number
    • typeToken: "TYPE"
    • type: string | Buffer
    • Optionalcallback: Callback<[cursor: string, elements: string[]]>

    Returns Promise<[cursor: string, elements: string[]]>

  • Parameters

    • cursor: string | number
    • countToken: "COUNT"
    • count: string | number
    • Optionalcallback: Callback<[cursor: string, elements: string[]]>

    Returns Promise<[cursor: string, elements: string[]]>

  • Parameters

    • cursor: string | number
    • countToken: "COUNT"
    • count: string | number
    • typeToken: "TYPE"
    • type: string | Buffer
    • Optionalcallback: Callback<[cursor: string, elements: string[]]>

    Returns Promise<[cursor: string, elements: string[]]>

  • Parameters

    • cursor: string | number
    • patternToken: "MATCH"
    • pattern: string
    • Optionalcallback: Callback<[cursor: string, elements: string[]]>

    Returns Promise<[cursor: string, elements: string[]]>

  • Parameters

    • cursor: string | number
    • patternToken: "MATCH"
    • pattern: string
    • typeToken: "TYPE"
    • type: string | Buffer
    • Optionalcallback: Callback<[cursor: string, elements: string[]]>

    Returns Promise<[cursor: string, elements: string[]]>

  • Parameters

    • cursor: string | number
    • patternToken: "MATCH"
    • pattern: string
    • countToken: "COUNT"
    • count: string | number
    • Optionalcallback: Callback<[cursor: string, elements: string[]]>

    Returns Promise<[cursor: string, elements: string[]]>

  • Parameters

    • cursor: string | number
    • patternToken: "MATCH"
    • pattern: string
    • countToken: "COUNT"
    • count: string | number
    • typeToken: "TYPE"
    • type: string | Buffer
    • Optionalcallback: Callback<[cursor: string, elements: string[]]>

    Returns Promise<[cursor: string, elements: string[]]>

  • Parameters

    • cursor: string | number
    • Optionalcallback: Callback<[cursor: Buffer, elements: Buffer[]]>

    Returns Promise<[cursor: Buffer, elements: Buffer[]]>

  • Parameters

    • cursor: string | number
    • typeToken: "TYPE"
    • type: string | Buffer
    • Optionalcallback: Callback<[cursor: Buffer, elements: Buffer[]]>

    Returns Promise<[cursor: Buffer, elements: Buffer[]]>

  • Parameters

    • cursor: string | number
    • countToken: "COUNT"
    • count: string | number
    • Optionalcallback: Callback<[cursor: Buffer, elements: Buffer[]]>

    Returns Promise<[cursor: Buffer, elements: Buffer[]]>

  • Parameters

    • cursor: string | number
    • countToken: "COUNT"
    • count: string | number
    • typeToken: "TYPE"
    • type: string | Buffer
    • Optionalcallback: Callback<[cursor: Buffer, elements: Buffer[]]>

    Returns Promise<[cursor: Buffer, elements: Buffer[]]>

  • Parameters

    • cursor: string | number
    • patternToken: "MATCH"
    • pattern: string
    • Optionalcallback: Callback<[cursor: Buffer, elements: Buffer[]]>

    Returns Promise<[cursor: Buffer, elements: Buffer[]]>

  • Parameters

    • cursor: string | number
    • patternToken: "MATCH"
    • pattern: string
    • typeToken: "TYPE"
    • type: string | Buffer
    • Optionalcallback: Callback<[cursor: Buffer, elements: Buffer[]]>

    Returns Promise<[cursor: Buffer, elements: Buffer[]]>

  • Parameters

    • cursor: string | number
    • patternToken: "MATCH"
    • pattern: string
    • countToken: "COUNT"
    • count: string | number
    • Optionalcallback: Callback<[cursor: Buffer, elements: Buffer[]]>

    Returns Promise<[cursor: Buffer, elements: Buffer[]]>

  • Parameters

    • cursor: string | number
    • patternToken: "MATCH"
    • pattern: string
    • countToken: "COUNT"
    • count: string | number
    • typeToken: "TYPE"
    • type: string | Buffer
    • Optionalcallback: Callback<[cursor: Buffer, elements: Buffer[]]>

    Returns Promise<[cursor: Buffer, elements: Buffer[]]>

  • Parameters

    • Optionaloptions: ScanStreamOptions

    Returns ScanStream

  • Parameters

    • Optionaloptions: ScanStreamOptions

    Returns ScanStream

  • Get the number of members in a set

    • group: set
    • complexity: O(1)
    • since: 1.0.0

    Parameters

    • key: RedisKey
    • Optionalcallback: Callback<number>

    Returns Promise<number>

  • Set the debug mode for executed scripts.

    • group: scripting
    • complexity: O(1)
    • since: 3.2.0

    Parameters

    • subcommand: "DEBUG"
    • yes: "YES"
    • Optionalcallback: Callback<unknown>

    Returns Promise<unknown>

  • Parameters

    • subcommand: "DEBUG"
    • sync: "SYNC"
    • Optionalcallback: Callback<unknown>

    Returns Promise<unknown>

  • Parameters

    • subcommand: "DEBUG"
    • no: "NO"
    • Optionalcallback: Callback<unknown>

    Returns Promise<unknown>

  • Check existence of scripts in the script cache.

    • group: scripting
    • complexity: O(N) with N being the number of scripts to check (so checking a single script is an O(1) operation).
    • since: 2.6.0

    Parameters

    • Rest...args: [subcommand: "EXISTS", ...sha1s: (string | Buffer)[], callback: Callback<unknown>]

    Returns Promise<unknown>

  • Parameters

    • Rest...args: [subcommand: "EXISTS", ...sha1s: (string | Buffer)[]]

    Returns Promise<unknown>

  • Remove all the scripts from the script cache.

    • group: scripting
    • complexity: O(N) with N being the number of scripts in cache
    • since: 2.6.0

    Parameters

    • subcommand: "FLUSH"
    • Optionalcallback: Callback<unknown>

    Returns Promise<unknown>

  • Parameters

    • subcommand: "FLUSH"
    • async: "ASYNC"
    • Optionalcallback: Callback<unknown>

    Returns Promise<unknown>

  • Parameters

    • subcommand: "FLUSH"
    • sync: "SYNC"
    • Optionalcallback: Callback<unknown>

    Returns Promise<unknown>

  • Show helpful text about the different subcommands

    • group: scripting
    • complexity: O(1)
    • since: 5.0.0

    Parameters

    • subcommand: "HELP"
    • Optionalcallback: Callback<unknown>

    Returns Promise<unknown>

  • Kill the script currently in execution.

    • group: scripting
    • complexity: O(1)
    • since: 2.6.0

    Parameters

    • subcommand: "KILL"
    • Optionalcallback: Callback<unknown>

    Returns Promise<unknown>

  • Load the specified Lua script into the script cache.

    • group: scripting
    • complexity: O(N) with N being the length in bytes of the script body.
    • since: 2.6.0

    Parameters

    • subcommand: "LOAD"
    • script: string | Buffer
    • Optionalcallback: Callback<unknown>

    Returns Promise<unknown>

  • Subtract multiple sets

    • group: set
    • complexity: O(N) where N is the total number of elements in all given sets.
    • since: 1.0.0

    Parameters

    • Rest...args: [...keys: RedisKey[], callback: Callback<string[]>]

    Returns Promise<string[]>

  • Parameters

    • Rest...args: [keys: RedisKey[], callback: Callback<string[]>]

    Returns Promise<string[]>

  • Parameters

    • Rest...args: RedisKey[]

    Returns Promise<string[]>

  • Parameters

    • Rest...args: [keys: RedisKey[]]

    Returns Promise<string[]>

  • Parameters

    • Rest...args: [...keys: RedisKey[], callback: Callback<Buffer[]>]

    Returns Promise<Buffer[]>

  • Parameters

    • Rest...args: [keys: RedisKey[], callback: Callback<Buffer[]>]

    Returns Promise<Buffer[]>

  • Parameters

    • Rest...args: RedisKey[]

    Returns Promise<Buffer[]>

  • Parameters

    • Rest...args: [keys: RedisKey[]]

    Returns Promise<Buffer[]>

  • Subtract multiple sets and store the resulting set in a key

    • group: set
    • complexity: O(N) where N is the total number of elements in all given sets.
    • since: 1.0.0

    Parameters

    • Rest...args: [destination: RedisKey, ...keys: RedisKey[], callback: Callback<number>]

    Returns Promise<number>

  • Parameters

    • Rest...args: [destination: RedisKey, keys: RedisKey[], callback: Callback<number>]

    Returns Promise<number>

  • Parameters

    • Rest...args: [destination: RedisKey, ...keys: RedisKey[]]

    Returns Promise<number>

  • Parameters

    • Rest...args: [destination: RedisKey, keys: RedisKey[]]

    Returns Promise<number>

  • Change the selected database for the current connection

    • group: connection
    • complexity: O(1)
    • since: 1.0.0

    Parameters

    • index: string | number
    • Optionalcallback: Callback<"OK">

    Returns Promise<"OK">

  • Set the string value of a key

    • group: string
    • complexity: O(1)
    • since: 1.0.0

    Parameters

    • key: RedisKey
    • value: string | number | Buffer
    • Optionalcallback: Callback<"OK">

    Returns Promise<"OK">

  • Parameters

    • key: RedisKey
    • value: string | number | Buffer
    • get: "GET"
    • Optionalcallback: Callback<null | string>

    Returns Promise<null | string>

  • Parameters

    • key: RedisKey
    • value: string | number | Buffer
    • nx: "NX"
    • Optionalcallback: Callback<null | "OK">

    Returns Promise<null | "OK">

  • Parameters

    • key: RedisKey
    • value: string | number | Buffer
    • nx: "NX"
    • get: "GET"
    • Optionalcallback: Callback<null | string>

    Returns Promise<null | string>

  • Parameters

    • key: RedisKey
    • value: string | number | Buffer
    • xx: "XX"
    • Optionalcallback: Callback<null | "OK">

    Returns Promise<null | "OK">

  • Parameters

    • key: RedisKey
    • value: string | number | Buffer
    • xx: "XX"
    • get: "GET"
    • Optionalcallback: Callback<null | string>

    Returns Promise<null | string>

  • Parameters

    • key: RedisKey
    • value: string | number | Buffer
    • secondsToken: "EX"
    • seconds: string | number
    • Optionalcallback: Callback<"OK">

    Returns Promise<"OK">

  • Parameters

    • key: RedisKey
    • value: string | number | Buffer
    • secondsToken: "EX"
    • seconds: string | number
    • get: "GET"
    • Optionalcallback: Callback<null | string>

    Returns Promise<null | string>

  • Parameters

    • key: RedisKey
    • value: string | number | Buffer
    • secondsToken: "EX"
    • seconds: string | number
    • nx: "NX"
    • Optionalcallback: Callback<null | "OK">

    Returns Promise<null | "OK">

  • Parameters

    • key: RedisKey
    • value: string | number | Buffer
    • secondsToken: "EX"
    • seconds: string | number
    • nx: "NX"
    • get: "GET"
    • Optionalcallback: Callback<null | string>

    Returns Promise<null | string>

  • Parameters

    • key: RedisKey
    • value: string | number | Buffer
    • secondsToken: "EX"
    • seconds: string | number
    • xx: "XX"
    • Optionalcallback: Callback<null | "OK">

    Returns Promise<null | "OK">

  • Parameters

    • key: RedisKey
    • value: string | number | Buffer
    • secondsToken: "EX"
    • seconds: string | number
    • xx: "XX"
    • get: "GET"
    • Optionalcallback: Callback<null | string>

    Returns Promise<null | string>

  • Parameters

    • key: RedisKey
    • value: string | number | Buffer
    • millisecondsToken: "PX"
    • milliseconds: string | number
    • Optionalcallback: Callback<"OK">

    Returns Promise<"OK">

  • Parameters

    • key: RedisKey
    • value: string | number | Buffer
    • millisecondsToken: "PX"
    • milliseconds: string | number
    • get: "GET"
    • Optionalcallback: Callback<null | string>

    Returns Promise<null | string>

  • Parameters

    • key: RedisKey
    • value: string | number | Buffer
    • millisecondsToken: "PX"
    • milliseconds: string | number
    • nx: "NX"
    • Optionalcallback: Callback<null | "OK">

    Returns Promise<null | "OK">

  • Parameters

    • key: RedisKey
    • value: string | number | Buffer
    • millisecondsToken: "PX"
    • milliseconds: string | number
    • nx: "NX"
    • get: "GET"
    • Optionalcallback: Callback<null | string>

    Returns Promise<null | string>

  • Parameters

    • key: RedisKey
    • value: string | number | Buffer
    • millisecondsToken: "PX"
    • milliseconds: string | number
    • xx: "XX"
    • Optionalcallback: Callback<null | "OK">

    Returns Promise<null | "OK">

  • Parameters

    • key: RedisKey
    • value: string | number | Buffer
    • millisecondsToken: "PX"
    • milliseconds: string | number
    • xx: "XX"
    • get: "GET"
    • Optionalcallback: Callback<null | string>

    Returns Promise<null | string>

  • Parameters

    • key: RedisKey
    • value: string | number | Buffer
    • unixTimeSecondsToken: "EXAT"
    • unixTimeSeconds: string | number
    • Optionalcallback: Callback<"OK">

    Returns Promise<"OK">

  • Parameters

    • key: RedisKey
    • value: string | number | Buffer
    • unixTimeSecondsToken: "EXAT"
    • unixTimeSeconds: string | number
    • get: "GET"
    • Optionalcallback: Callback<null | string>

    Returns Promise<null | string>

  • Parameters

    • key: RedisKey
    • value: string | number | Buffer
    • unixTimeSecondsToken: "EXAT"
    • unixTimeSeconds: string | number
    • nx: "NX"
    • Optionalcallback: Callback<null | "OK">

    Returns Promise<null | "OK">

  • Parameters

    • key: RedisKey
    • value: string | number | Buffer
    • unixTimeSecondsToken: "EXAT"
    • unixTimeSeconds: string | number
    • nx: "NX"
    • get: "GET"
    • Optionalcallback: Callback<null | string>

    Returns Promise<null | string>

  • Parameters

    • key: RedisKey
    • value: string | number | Buffer
    • unixTimeSecondsToken: "EXAT"
    • unixTimeSeconds: string | number
    • xx: "XX"
    • Optionalcallback: Callback<null | "OK">

    Returns Promise<null | "OK">

  • Parameters

    • key: RedisKey
    • value: string | number | Buffer
    • unixTimeSecondsToken: "EXAT"
    • unixTimeSeconds: string | number
    • xx: "XX"
    • get: "GET"
    • Optionalcallback: Callback<null | string>

    Returns Promise<null | string>

  • Parameters

    • key: RedisKey
    • value: string | number | Buffer
    • unixTimeMillisecondsToken: "PXAT"
    • unixTimeMilliseconds: string | number
    • Optionalcallback: Callback<"OK">

    Returns Promise<"OK">

  • Parameters

    • key: RedisKey
    • value: string | number | Buffer
    • unixTimeMillisecondsToken: "PXAT"
    • unixTimeMilliseconds: string | number
    • get: "GET"
    • Optionalcallback: Callback<null | string>

    Returns Promise<null | string>

  • Parameters

    • key: RedisKey
    • value: string | number | Buffer
    • unixTimeMillisecondsToken: "PXAT"
    • unixTimeMilliseconds: string | number
    • nx: "NX"
    • Optionalcallback: Callback<null | "OK">

    Returns Promise<null | "OK">

  • Parameters

    • key: RedisKey
    • value: string | number | Buffer
    • unixTimeMillisecondsToken: "PXAT"
    • unixTimeMilliseconds: string | number
    • nx: "NX"
    • get: "GET"
    • Optionalcallback: Callback<null | string>

    Returns Promise<null | string>

  • Parameters

    • key: RedisKey
    • value: string | number | Buffer
    • unixTimeMillisecondsToken: "PXAT"
    • unixTimeMilliseconds: string | number
    • xx: "XX"
    • Optionalcallback: Callback<null | "OK">

    Returns Promise<null | "OK">

  • Parameters

    • key: RedisKey
    • value: string | number | Buffer
    • unixTimeMillisecondsToken: "PXAT"
    • unixTimeMilliseconds: string | number
    • xx: "XX"
    • get: "GET"
    • Optionalcallback: Callback<null | string>

    Returns Promise<null | string>

  • Parameters

    • key: RedisKey
    • value: string | number | Buffer
    • keepttl: "KEEPTTL"
    • Optionalcallback: Callback<"OK">

    Returns Promise<"OK">

  • Parameters

    • key: RedisKey
    • value: string | number | Buffer
    • keepttl: "KEEPTTL"
    • get: "GET"
    • Optionalcallback: Callback<null | string>

    Returns Promise<null | string>

  • Parameters

    • key: RedisKey
    • value: string | number | Buffer
    • keepttl: "KEEPTTL"
    • nx: "NX"
    • Optionalcallback: Callback<null | "OK">

    Returns Promise<null | "OK">

  • Parameters

    • key: RedisKey
    • value: string | number | Buffer
    • keepttl: "KEEPTTL"
    • nx: "NX"
    • get: "GET"
    • Optionalcallback: Callback<null | string>

    Returns Promise<null | string>

  • Parameters

    • key: RedisKey
    • value: string | number | Buffer
    • keepttl: "KEEPTTL"
    • xx: "XX"
    • Optionalcallback: Callback<null | "OK">

    Returns Promise<null | "OK">

  • Parameters

    • key: RedisKey
    • value: string | number | Buffer
    • keepttl: "KEEPTTL"
    • xx: "XX"
    • get: "GET"
    • Optionalcallback: Callback<null | string>

    Returns Promise<null | string>

  • Sets or clears the bit at offset in the string value stored at key

    • group: bitmap
    • complexity: O(1)
    • since: 2.2.0

    Parameters

    • key: RedisKey
    • offset: string | number
    • value: string | number
    • Optionalcallback: Callback<number>

    Returns Promise<number>

  • Parameters

    • key: RedisKey
    • value: string | number | Buffer
    • get: "GET"
    • Optionalcallback: Callback<null | Buffer>

    Returns Promise<null | Buffer>

  • Parameters

    • key: RedisKey
    • value: string | number | Buffer
    • nx: "NX"
    • get: "GET"
    • Optionalcallback: Callback<null | Buffer>

    Returns Promise<null | Buffer>

  • Parameters

    • key: RedisKey
    • value: string | number | Buffer
    • xx: "XX"
    • get: "GET"
    • Optionalcallback: Callback<null | Buffer>

    Returns Promise<null | Buffer>

  • Parameters

    • key: RedisKey
    • value: string | number | Buffer
    • secondsToken: "EX"
    • seconds: string | number
    • get: "GET"
    • Optionalcallback: Callback<null | Buffer>

    Returns Promise<null | Buffer>

  • Parameters

    • key: RedisKey
    • value: string | number | Buffer
    • secondsToken: "EX"
    • seconds: string | number
    • nx: "NX"
    • get: "GET"
    • Optionalcallback: Callback<null | Buffer>

    Returns Promise<null | Buffer>

  • Parameters

    • key: RedisKey
    • value: string | number | Buffer
    • secondsToken: "EX"
    • seconds: string | number
    • xx: "XX"
    • get: "GET"
    • Optionalcallback: Callback<null | Buffer>

    Returns Promise<null | Buffer>

  • Parameters

    • key: RedisKey
    • value: string | number | Buffer
    • millisecondsToken: "PX"
    • milliseconds: string | number
    • get: "GET"
    • Optionalcallback: Callback<null | Buffer>

    Returns Promise<null | Buffer>

  • Parameters

    • key: RedisKey
    • value: string | number | Buffer
    • millisecondsToken: "PX"
    • milliseconds: string | number
    • nx: "NX"
    • get: "GET"
    • Optionalcallback: Callback<null | Buffer>

    Returns Promise<null | Buffer>

  • Parameters

    • key: RedisKey
    • value: string | number | Buffer
    • millisecondsToken: "PX"
    • milliseconds: string | number
    • xx: "XX"
    • get: "GET"
    • Optionalcallback: Callback<null | Buffer>

    Returns Promise<null | Buffer>

  • Parameters

    • key: RedisKey
    • value: string | number | Buffer
    • unixTimeSecondsToken: "EXAT"
    • unixTimeSeconds: string | number
    • get: "GET"
    • Optionalcallback: Callback<null | Buffer>

    Returns Promise<null | Buffer>

  • Parameters

    • key: RedisKey
    • value: string | number | Buffer
    • unixTimeSecondsToken: "EXAT"
    • unixTimeSeconds: string | number
    • nx: "NX"
    • get: "GET"
    • Optionalcallback: Callback<null | Buffer>

    Returns Promise<null | Buffer>

  • Parameters

    • key: RedisKey
    • value: string | number | Buffer
    • unixTimeSecondsToken: "EXAT"
    • unixTimeSeconds: string | number
    • xx: "XX"
    • get: "GET"
    • Optionalcallback: Callback<null | Buffer>

    Returns Promise<null | Buffer>

  • Parameters

    • key: RedisKey
    • value: string | number | Buffer
    • unixTimeMillisecondsToken: "PXAT"
    • unixTimeMilliseconds: string | number
    • get: "GET"
    • Optionalcallback: Callback<null | Buffer>

    Returns Promise<null | Buffer>

  • Parameters

    • key: RedisKey
    • value: string | number | Buffer
    • unixTimeMillisecondsToken: "PXAT"
    • unixTimeMilliseconds: string | number
    • nx: "NX"
    • get: "GET"
    • Optionalcallback: Callback<null | Buffer>

    Returns Promise<null | Buffer>

  • Parameters

    • key: RedisKey
    • value: string | number | Buffer
    • unixTimeMillisecondsToken: "PXAT"
    • unixTimeMilliseconds: string | number
    • xx: "XX"
    • get: "GET"
    • Optionalcallback: Callback<null | Buffer>

    Returns Promise<null | Buffer>

  • Parameters

    • key: RedisKey
    • value: string | number | Buffer
    • keepttl: "KEEPTTL"
    • get: "GET"
    • Optionalcallback: Callback<null | Buffer>

    Returns Promise<null | Buffer>

  • Parameters

    • key: RedisKey
    • value: string | number | Buffer
    • keepttl: "KEEPTTL"
    • nx: "NX"
    • get: "GET"
    • Optionalcallback: Callback<null | Buffer>

    Returns Promise<null | Buffer>

  • Parameters

    • key: RedisKey
    • value: string | number | Buffer
    • keepttl: "KEEPTTL"
    • xx: "XX"
    • get: "GET"
    • Optionalcallback: Callback<null | Buffer>

    Returns Promise<null | Buffer>

  • Set the value and expiration of a key

    • group: string
    • complexity: O(1)
    • since: 2.0.0

    Parameters

    • key: RedisKey
    • seconds: string | number
    • value: string | number | Buffer
    • Optionalcallback: Callback<"OK">

    Returns Promise<"OK">

  • By default EventEmitters will print a warning if more than 10 listeners are added for a particular event. This is a useful default that helps finding memory leaks. The emitter.setMaxListeners() method allows the limit to be modified for this specific EventEmitter instance. The value can be set to Infinity (or 0) to indicate an unlimited number of listeners.

    Returns a reference to the EventEmitter, so that calls can be chained.

    Parameters

    • n: number

    Returns this

    v0.3.5

  • Set the value of a key, only if the key does not exist

    • group: string
    • complexity: O(1)
    • since: 1.0.0

    Parameters

    • key: RedisKey
    • value: string | number | Buffer
    • Optionalcallback: Callback<number>

    Returns Promise<number>

  • Overwrite part of a string at key starting at the specified offset

    • group: string
    • complexity: O(1), not counting the time taken to copy the new string in place. Usually, this string is very small so the amortized complexity is O(1). Otherwise, complexity is O(M) with M being the length of the value argument.
    • since: 2.2.0

    Parameters

    • key: RedisKey
    • offset: string | number
    • value: string | number | Buffer
    • Optionalcallback: Callback<number>

    Returns Promise<number>

  • Synchronously save the dataset to disk and then shut down the server

    • group: server
    • complexity: O(N) when saving, where N is the total number of keys in all databases when saving data, otherwise O(1)
    • since: 1.0.0

    Parameters

    • Optionalcallback: Callback<"OK">

    Returns Promise<"OK">

  • Parameters

    • abort: "ABORT"
    • Optionalcallback: Callback<"OK">

    Returns Promise<"OK">

  • Parameters

    • force: "FORCE"
    • Optionalcallback: Callback<"OK">

    Returns Promise<"OK">

  • Parameters

    • force: "FORCE"
    • abort: "ABORT"
    • Optionalcallback: Callback<"OK">

    Returns Promise<"OK">

  • Parameters

    • now: "NOW"
    • Optionalcallback: Callback<"OK">

    Returns Promise<"OK">

  • Parameters

    • now: "NOW"
    • abort: "ABORT"
    • Optionalcallback: Callback<"OK">

    Returns Promise<"OK">

  • Parameters

    • now: "NOW"
    • force: "FORCE"
    • Optionalcallback: Callback<"OK">

    Returns Promise<"OK">

  • Parameters

    • now: "NOW"
    • force: "FORCE"
    • abort: "ABORT"
    • Optionalcallback: Callback<"OK">

    Returns Promise<"OK">

  • Parameters

    • nosave: "NOSAVE"
    • Optionalcallback: Callback<"OK">

    Returns Promise<"OK">

  • Parameters

    • nosave: "NOSAVE"
    • abort: "ABORT"
    • Optionalcallback: Callback<"OK">

    Returns Promise<"OK">

  • Parameters

    • nosave: "NOSAVE"
    • force: "FORCE"
    • Optionalcallback: Callback<"OK">

    Returns Promise<"OK">

  • Parameters

    • nosave: "NOSAVE"
    • force: "FORCE"
    • abort: "ABORT"
    • Optionalcallback: Callback<"OK">

    Returns Promise<"OK">

  • Parameters

    • nosave: "NOSAVE"
    • now: "NOW"
    • Optionalcallback: Callback<"OK">

    Returns Promise<"OK">

  • Parameters

    • nosave: "NOSAVE"
    • now: "NOW"
    • abort: "ABORT"
    • Optionalcallback: Callback<"OK">

    Returns Promise<"OK">

  • Parameters

    • nosave: "NOSAVE"
    • now: "NOW"
    • force: "FORCE"
    • Optionalcallback: Callback<"OK">

    Returns Promise<"OK">

  • Parameters

    • nosave: "NOSAVE"
    • now: "NOW"
    • force: "FORCE"
    • abort: "ABORT"
    • Optionalcallback: Callback<"OK">

    Returns Promise<"OK">

  • Parameters

    • save: "SAVE"
    • Optionalcallback: Callback<"OK">

    Returns Promise<"OK">

  • Parameters

    • save: "SAVE"
    • abort: "ABORT"
    • Optionalcallback: Callback<"OK">

    Returns Promise<"OK">

  • Parameters

    • save: "SAVE"
    • force: "FORCE"
    • Optionalcallback: Callback<"OK">

    Returns Promise<"OK">

  • Parameters

    • save: "SAVE"
    • force: "FORCE"
    • abort: "ABORT"
    • Optionalcallback: Callback<"OK">

    Returns Promise<"OK">

  • Parameters

    • save: "SAVE"
    • now: "NOW"
    • Optionalcallback: Callback<"OK">

    Returns Promise<"OK">

  • Parameters

    • save: "SAVE"
    • now: "NOW"
    • abort: "ABORT"
    • Optionalcallback: Callback<"OK">

    Returns Promise<"OK">

  • Parameters

    • save: "SAVE"
    • now: "NOW"
    • force: "FORCE"
    • Optionalcallback: Callback<"OK">

    Returns Promise<"OK">

  • Parameters

    • save: "SAVE"
    • now: "NOW"
    • force: "FORCE"
    • abort: "ABORT"
    • Optionalcallback: Callback<"OK">

    Returns Promise<"OK">

  • Intersect multiple sets

    • group: set
    • complexity: O(N*M) worst case where N is the cardinality of the smallest set and M is the number of sets.
    • since: 1.0.0

    Parameters

    • Rest...args: [...keys: RedisKey[], callback: Callback<string[]>]

    Returns Promise<string[]>

  • Parameters

    • Rest...args: [keys: RedisKey[], callback: Callback<string[]>]

    Returns Promise<string[]>

  • Parameters

    • Rest...args: RedisKey[]

    Returns Promise<string[]>

  • Parameters

    • Rest...args: [keys: RedisKey[]]

    Returns Promise<string[]>

  • Parameters

    • Rest...args: [...keys: RedisKey[], callback: Callback<Buffer[]>]

    Returns Promise<Buffer[]>

  • Parameters

    • Rest...args: [keys: RedisKey[], callback: Callback<Buffer[]>]

    Returns Promise<Buffer[]>

  • Parameters

    • Rest...args: RedisKey[]

    Returns Promise<Buffer[]>

  • Parameters

    • Rest...args: [keys: RedisKey[]]

    Returns Promise<Buffer[]>

  • Intersect multiple sets and return the cardinality of the result

    • group: set
    • complexity: O(N*M) worst case where N is the cardinality of the smallest set and M is the number of sets.
    • since: 7.0.0

    Parameters

    • Rest...args: [numkeys: string | number, ...keys: RedisKey[], callback: Callback<number>]

    Returns Promise<number>

  • Parameters

    • Rest...args: [numkeys: string | number, keys: RedisKey[], callback: Callback<number>]

    Returns Promise<number>

  • Parameters

    • Rest...args: [numkeys: string | number, ...keys: RedisKey[]]

    Returns Promise<number>

  • Parameters

    • Rest...args: [numkeys: string | number, keys: RedisKey[]]

    Returns Promise<number>

  • Parameters

    • Rest...args: [numkeys: string | number, ...keys: RedisKey[], limitToken: "LIMIT", limit: string | number, callback: Callback<number>]

    Returns Promise<number>

  • Parameters

    • Rest...args: [numkeys: string | number, keys: RedisKey[], limitToken: "LIMIT", limit: string | number, callback: Callback<number>]

    Returns Promise<number>

  • Parameters

    • Rest...args: [numkeys: string | number, ...keys: RedisKey[], limitToken: "LIMIT", limit: string | number]

    Returns Promise<number>

  • Parameters

    • Rest...args: [numkeys: string | number, keys: RedisKey[], limitToken: "LIMIT", limit: string | number]

    Returns Promise<number>

  • Intersect multiple sets and store the resulting set in a key

    • group: set
    • complexity: O(N*M) worst case where N is the cardinality of the smallest set and M is the number of sets.
    • since: 1.0.0

    Parameters

    • Rest...args: [destination: RedisKey, ...keys: RedisKey[], callback: Callback<number>]

    Returns Promise<number>

  • Parameters

    • Rest...args: [destination: RedisKey, keys: RedisKey[], callback: Callback<number>]

    Returns Promise<number>

  • Parameters

    • Rest...args: [destination: RedisKey, ...keys: RedisKey[]]

    Returns Promise<number>

  • Parameters

    • Rest...args: [destination: RedisKey, keys: RedisKey[]]

    Returns Promise<number>

  • Determine if a given value is a member of a set

    • group: set
    • complexity: O(1)
    • since: 1.0.0

    Parameters

    • key: RedisKey
    • member: string | number | Buffer
    • Optionalcallback: Callback<number>

    Returns Promise<number>

  • Make the server a replica of another instance, or promote it as master.

    • group: server
    • complexity: O(1)
    • since: 1.0.0

    Parameters

    • host: string | Buffer
    • port: string | number
    • Optionalcallback: Callback<"OK">

    Returns Promise<"OK">

  • Get the slow log's entries

    • group: server
    • complexity: O(N) where N is the number of entries returned
    • since: 2.2.12

    Parameters

    • subcommand: "GET"
    • Optionalcallback: Callback<unknown>

    Returns Promise<unknown>

  • Parameters

    • subcommand: "GET"
    • count: string | number
    • Optionalcallback: Callback<unknown>

    Returns Promise<unknown>

  • Show helpful text about the different subcommands

    • group: server
    • complexity: O(1)
    • since: 6.2.0

    Parameters

    • subcommand: "HELP"
    • Optionalcallback: Callback<unknown>

    Returns Promise<unknown>

  • Get the slow log's length

    • group: server
    • complexity: O(1)
    • since: 2.2.12

    Parameters

    • subcommand: "LEN"
    • Optionalcallback: Callback<unknown>

    Returns Promise<unknown>

  • Clear all entries from the slow log

    • group: server
    • complexity: O(N) where N is the number of entries in the slowlog
    • since: 2.2.12

    Parameters

    • subcommand: "RESET"
    • Optionalcallback: Callback<unknown>

    Returns Promise<unknown>

  • Get all the members in a set

    • group: set
    • complexity: O(N) where N is the set cardinality.
    • since: 1.0.0

    Parameters

    • key: RedisKey
    • Optionalcallback: Callback<string[]>

    Returns Promise<string[]>

  • Parameters

    • key: RedisKey
    • Optionalcallback: Callback<Buffer[]>

    Returns Promise<Buffer[]>

  • Returns the membership associated with the given elements for a set

    • group: set
    • complexity: O(N) where N is the number of elements being checked for membership
    • since: 6.2.0

    Parameters

    • Rest...args: [key: RedisKey, ...members: (string | number | Buffer)[], callback: Callback<number[]>]

    Returns Promise<number[]>

  • Parameters

    • Rest...args: [key: RedisKey, members: (string | number | Buffer)[], callback: Callback<number[]>]

    Returns Promise<number[]>

  • Parameters

    • Rest...args: [key: RedisKey, ...members: (string | number | Buffer)[]]

    Returns Promise<number[]>

  • Parameters

    • Rest...args: [key: RedisKey, members: (string | number | Buffer)[]]

    Returns Promise<number[]>

  • Move a member from one set to another

    • group: set
    • complexity: O(1)
    • since: 1.0.0

    Parameters

    • source: RedisKey
    • destination: RedisKey
    • member: string | number | Buffer
    • Optionalcallback: Callback<number>

    Returns Promise<number>

  • Sort the elements in a list, set or sorted set

    • group: generic
    • complexity: O(N+M*log(M)) where N is the number of elements in the list or set to sort, and M the number of returned elements. When the elements are not sorted, complexity is O(N).
    • since: 1.0.0

    Parameters

    • Rest...args: [key: RedisKey, ...args: RedisValue[], callback: Callback<unknown>]

    Returns Promise<unknown>

  • Parameters

    • Rest...args: [key: RedisKey, ...args: RedisValue[]]

    Returns Promise<unknown>

  • Sort the elements in a list, set or sorted set. Read-only variant of SORT.

    • group: generic
    • complexity: O(N+M*log(M)) where N is the number of elements in the list or set to sort, and M the number of returned elements. When the elements are not sorted, complexity is O(N).
    • since: 7.0.0

    Parameters

    • key: RedisKey
    • Optionalcallback: Callback<unknown>

    Returns Promise<unknown>

  • Parameters

    • key: RedisKey
    • alpha: "ALPHA"
    • Optionalcallback: Callback<unknown>

    Returns Promise<unknown>

  • Parameters

    • key: RedisKey
    • asc: "ASC"
    • Optionalcallback: Callback<unknown>

    Returns Promise<unknown>

  • Parameters

    • key: RedisKey
    • asc: "ASC"
    • alpha: "ALPHA"
    • Optionalcallback: Callback<unknown>

    Returns Promise<unknown>

  • Parameters

    • key: RedisKey
    • desc: "DESC"
    • Optionalcallback: Callback<unknown>

    Returns Promise<unknown>

  • Parameters

    • key: RedisKey
    • desc: "DESC"
    • alpha: "ALPHA"
    • Optionalcallback: Callback<unknown>

    Returns Promise<unknown>

  • Parameters

    • Rest...args: [key: RedisKey, patternToken: "GET", ...patterns: string[], callback: Callback<unknown>]

    Returns Promise<unknown>

  • Parameters

    • Rest...args: [key: RedisKey, patternToken: "GET", ...patterns: string[]]

    Returns Promise<unknown>

  • Parameters

    • Rest...args: [key: RedisKey, patternToken: "GET", ...patterns: string[], alpha: "ALPHA", callback: Callback<unknown>]

    Returns Promise<unknown>

  • Parameters

    • Rest...args: [key: RedisKey, patternToken: "GET", ...patterns: string[], alpha: "ALPHA"]

    Returns Promise<unknown>

  • Parameters

    • Rest...args: [key: RedisKey, patternToken: "GET", ...patterns: string[], asc: "ASC", callback: Callback<unknown>]

    Returns Promise<unknown>

  • Parameters

    • Rest...args: [key: RedisKey, patternToken: "GET", ...patterns: string[], asc: "ASC"]

    Returns Promise<unknown>

  • Parameters

    • Rest...args: [key: RedisKey, patternToken: "GET", ...patterns: string[], asc: "ASC", alpha: "ALPHA", callback: Callback<unknown>]

    Returns Promise<unknown>

  • Parameters

    • Rest...args: [key: RedisKey, patternToken: "GET", ...patterns: string[], asc: "ASC", alpha: "ALPHA"]

    Returns Promise<unknown>

  • Parameters

    • Rest...args: [key: RedisKey, patternToken: "GET", ...patterns: string[], desc: "DESC", callback: Callback<unknown>]

    Returns Promise<unknown>

  • Parameters

    • Rest...args: [key: RedisKey, patternToken: "GET", ...patterns: string[], desc: "DESC"]

    Returns Promise<unknown>

  • Parameters

    • Rest...args: [key: RedisKey, patternToken: "GET", ...patterns: string[], desc: "DESC", alpha: "ALPHA", callback: Callback<unknown>]

    Returns Promise<unknown>

  • Parameters

    • Rest...args: [key: RedisKey, patternToken: "GET", ...patterns: string[], desc: "DESC", alpha: "ALPHA"]

    Returns Promise<unknown>

  • Parameters

    • key: RedisKey
    • offsetCountToken: "LIMIT"
    • offset: string | number
    • count: string | number
    • Optionalcallback: Callback<unknown>

    Returns Promise<unknown>

  • Parameters

    • key: RedisKey
    • offsetCountToken: "LIMIT"
    • offset: string | number
    • count: string | number
    • alpha: "ALPHA"
    • Optionalcallback: Callback<unknown>

    Returns Promise<unknown>

  • Parameters

    • key: RedisKey
    • offsetCountToken: "LIMIT"
    • offset: string | number
    • count: string | number
    • asc: "ASC"
    • Optionalcallback: Callback<unknown>

    Returns Promise<unknown>

  • Parameters

    • key: RedisKey
    • offsetCountToken: "LIMIT"
    • offset: string | number
    • count: string | number
    • asc: "ASC"
    • alpha: "ALPHA"
    • Optionalcallback: Callback<unknown>

    Returns Promise<unknown>

  • Parameters

    • key: RedisKey
    • offsetCountToken: "LIMIT"
    • offset: string | number
    • count: string | number
    • desc: "DESC"
    • Optionalcallback: Callback<unknown>

    Returns Promise<unknown>

  • Parameters

    • key: RedisKey
    • offsetCountToken: "LIMIT"
    • offset: string | number
    • count: string | number
    • desc: "DESC"
    • alpha: "ALPHA"
    • Optionalcallback: Callback<unknown>

    Returns Promise<unknown>

  • Parameters

    • Rest...args: [key: RedisKey, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken: "GET", ...patterns: string[], callback: Callback<unknown>]

    Returns Promise<unknown>

  • Parameters

    • Rest...args: [key: RedisKey, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken: "GET", ...patterns: string[]]

    Returns Promise<unknown>

  • Parameters

    • Rest...args: [key: RedisKey, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken: "GET", ...patterns: string[], alpha: "ALPHA", callback: Callback<unknown>]

    Returns Promise<unknown>

  • Parameters

    • Rest...args: [key: RedisKey, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken: "GET", ...patterns: string[], alpha: "ALPHA"]

    Returns Promise<unknown>

  • Parameters

    • Rest...args: [key: RedisKey, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken: "GET", ...patterns: string[], asc: "ASC", callback: Callback<unknown>]

    Returns Promise<unknown>

  • Parameters

    • Rest...args: [key: RedisKey, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken: "GET", ...patterns: string[], asc: "ASC"]

    Returns Promise<unknown>

  • Parameters

    • Rest...args: [key: RedisKey, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken: "GET", ...patterns: string[], asc: "ASC", alpha: "ALPHA", callback: Callback<unknown>]

    Returns Promise<unknown>

  • Parameters

    • Rest...args: [key: RedisKey, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken: "GET", ...patterns: string[], asc: "ASC", alpha: "ALPHA"]

    Returns Promise<unknown>

  • Parameters

    • Rest...args: [key: RedisKey, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken: "GET", ...patterns: string[], desc: "DESC", callback: Callback<unknown>]

    Returns Promise<unknown>

  • Parameters

    • Rest...args: [key: RedisKey, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken: "GET", ...patterns: string[], desc: "DESC"]

    Returns Promise<unknown>

  • Parameters

    • Rest...args: [key: RedisKey, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken: "GET", ...patterns: string[], desc: "DESC", alpha: "ALPHA", callback: Callback<unknown>]

    Returns Promise<unknown>

  • Parameters

    • Rest...args: [key: RedisKey, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken: "GET", ...patterns: string[], desc: "DESC", alpha: "ALPHA"]

    Returns Promise<unknown>

  • Parameters

    • key: RedisKey
    • patternToken: "BY"
    • pattern: string
    • Optionalcallback: Callback<unknown>

    Returns Promise<unknown>

  • Parameters

    • key: RedisKey
    • patternToken: "BY"
    • pattern: string
    • alpha: "ALPHA"
    • Optionalcallback: Callback<unknown>

    Returns Promise<unknown>

  • Parameters

    • key: RedisKey
    • patternToken: "BY"
    • pattern: string
    • asc: "ASC"
    • Optionalcallback: Callback<unknown>

    Returns Promise<unknown>

  • Parameters

    • key: RedisKey
    • patternToken: "BY"
    • pattern: string
    • asc: "ASC"
    • alpha: "ALPHA"
    • Optionalcallback: Callback<unknown>

    Returns Promise<unknown>

  • Parameters

    • key: RedisKey
    • patternToken: "BY"
    • pattern: string
    • desc: "DESC"
    • Optionalcallback: Callback<unknown>

    Returns Promise<unknown>

  • Parameters

    • key: RedisKey
    • patternToken: "BY"
    • pattern: string
    • desc: "DESC"
    • alpha: "ALPHA"
    • Optionalcallback: Callback<unknown>

    Returns Promise<unknown>

  • Parameters

    • Rest...args: [key: RedisKey, patternToken: "BY", pattern: string, patternToken1: "GET", ...pattern1s: string[], callback: Callback<unknown>]

    Returns Promise<unknown>

  • Parameters

    • Rest...args: [key: RedisKey, patternToken: "BY", pattern: string, patternToken1: "GET", ...pattern1s: string[]]

    Returns Promise<unknown>

  • Parameters

    • Rest...args: [key: RedisKey, patternToken: "BY", pattern: string, patternToken1: "GET", ...pattern1s: string[], alpha: "ALPHA", callback: Callback<unknown>]

    Returns Promise<unknown>

  • Parameters

    • Rest...args: [key: RedisKey, patternToken: "BY", pattern: string, patternToken1: "GET", ...pattern1s: string[], alpha: "ALPHA"]

    Returns Promise<unknown>

  • Parameters

    • Rest...args: [key: RedisKey, patternToken: "BY", pattern: string, patternToken1: "GET", ...pattern1s: string[], asc: "ASC", callback: Callback<unknown>]

    Returns Promise<unknown>

  • Parameters

    • Rest...args: [key: RedisKey, patternToken: "BY", pattern: string, patternToken1: "GET", ...pattern1s: string[], asc: "ASC"]

    Returns Promise<unknown>

  • Parameters

    • Rest...args: [key: RedisKey, patternToken: "BY", pattern: string, patternToken1: "GET", ...pattern1s: string[], asc: "ASC", alpha: "ALPHA", callback: Callback<unknown>]

    Returns Promise<unknown>

  • Parameters

    • Rest...args: [key: RedisKey, patternToken: "BY", pattern: string, patternToken1: "GET", ...pattern1s: string[], asc: "ASC", alpha: "ALPHA"]

    Returns Promise<unknown>

  • Parameters

    • Rest...args: [key: RedisKey, patternToken: "BY", pattern: string, patternToken1: "GET", ...pattern1s: string[], desc: "DESC", callback: Callback<unknown>]

    Returns Promise<unknown>

  • Parameters

    • Rest...args: [key: RedisKey, patternToken: "BY", pattern: string, patternToken1: "GET", ...pattern1s: string[], desc: "DESC"]

    Returns Promise<unknown>

  • Parameters

    • Rest...args: [key: RedisKey, patternToken: "BY", pattern: string, patternToken1: "GET", ...pattern1s: string[], desc: "DESC", alpha: "ALPHA", callback: Callback<unknown>]

    Returns Promise<unknown>

  • Parameters

    • Rest...args: [key: RedisKey, patternToken: "BY", pattern: string, patternToken1: "GET", ...pattern1s: string[], desc: "DESC", alpha: "ALPHA"]

    Returns Promise<unknown>

  • Parameters

    • key: RedisKey
    • patternToken: "BY"
    • pattern: string
    • offsetCountToken: "LIMIT"
    • offset: string | number
    • count: string | number
    • Optionalcallback: Callback<unknown>

    Returns Promise<unknown>

  • Parameters

    • key: RedisKey
    • patternToken: "BY"
    • pattern: string
    • offsetCountToken: "LIMIT"
    • offset: string | number
    • count: string | number
    • alpha: "ALPHA"
    • Optionalcallback: Callback<unknown>

    Returns Promise<unknown>

  • Parameters

    • key: RedisKey
    • patternToken: "BY"
    • pattern: string
    • offsetCountToken: "LIMIT"
    • offset: string | number
    • count: string | number
    • asc: "ASC"
    • Optionalcallback: Callback<unknown>

    Returns Promise<unknown>

  • Parameters

    • key: RedisKey
    • patternToken: "BY"
    • pattern: string
    • offsetCountToken: "LIMIT"
    • offset: string | number
    • count: string | number
    • asc: "ASC"
    • alpha: "ALPHA"
    • Optionalcallback: Callback<unknown>

    Returns Promise<unknown>

  • Parameters

    • key: RedisKey
    • patternToken: "BY"
    • pattern: string
    • offsetCountToken: "LIMIT"
    • offset: string | number
    • count: string | number
    • desc: "DESC"
    • Optionalcallback: Callback<unknown>

    Returns Promise<unknown>

  • Parameters

    • key: RedisKey
    • patternToken: "BY"
    • pattern: string
    • offsetCountToken: "LIMIT"
    • offset: string | number
    • count: string | number
    • desc: "DESC"
    • alpha: "ALPHA"
    • Optionalcallback: Callback<unknown>

    Returns Promise<unknown>

  • Parameters

    • Rest...args: [key: RedisKey, patternToken: "BY", pattern: string, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken1: "GET", ...pattern1s: string[], callback: Callback<unknown>]

    Returns Promise<unknown>

  • Parameters

    • Rest...args: [key: RedisKey, patternToken: "BY", pattern: string, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken1: "GET", ...pattern1s: string[]]

    Returns Promise<unknown>

  • Parameters

    • Rest...args: [key: RedisKey, patternToken: "BY", pattern: string, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken1: "GET", ...pattern1s: string[], alpha: "ALPHA", callback: Callback<unknown>]

    Returns Promise<unknown>

  • Parameters

    • Rest...args: [key: RedisKey, patternToken: "BY", pattern: string, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken1: "GET", ...pattern1s: string[], alpha: "ALPHA"]

    Returns Promise<unknown>

  • Parameters

    • Rest...args: [key: RedisKey, patternToken: "BY", pattern: string, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken1: "GET", ...pattern1s: string[], asc: "ASC", callback: Callback<unknown>]

    Returns Promise<unknown>

  • Parameters

    • Rest...args: [key: RedisKey, patternToken: "BY", pattern: string, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken1: "GET", ...pattern1s: string[], asc: "ASC"]

    Returns Promise<unknown>

  • Parameters

    • Rest...args: [key: RedisKey, patternToken: "BY", pattern: string, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken1: "GET", ...pattern1s: string[], asc: "ASC", alpha: "ALPHA", callback: Callback<unknown>]

    Returns Promise<unknown>

  • Parameters

    • Rest...args: [key: RedisKey, patternToken: "BY", pattern: string, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken1: "GET", ...pattern1s: string[], asc: "ASC", alpha: "ALPHA"]

    Returns Promise<unknown>

  • Parameters

    • Rest...args: [key: RedisKey, patternToken: "BY", pattern: string, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken1: "GET", ...pattern1s: string[], desc: "DESC", callback: Callback<unknown>]

    Returns Promise<unknown>

  • Parameters

    • Rest...args: [key: RedisKey, patternToken: "BY", pattern: string, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken1: "GET", ...pattern1s: string[], desc: "DESC"]

    Returns Promise<unknown>

  • Parameters

    • Rest...args: [key: RedisKey, patternToken: "BY", pattern: string, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken1: "GET", ...pattern1s: string[], desc: "DESC", alpha: "ALPHA", callback: Callback<unknown>]

    Returns Promise<unknown>

  • Parameters

    • Rest...args: [key: RedisKey, patternToken: "BY", pattern: string, offsetCountToken: "LIMIT", offset: string | number, count: string | number, patternToken1: "GET", ...pattern1s: string[], desc: "DESC", alpha: "ALPHA"]

    Returns Promise<unknown>

  • Remove and return one or multiple random members from a set

    • group: set
    • complexity: Without the count argument O(1), otherwise O(N) where N is the value of the passed count.
    • since: 1.0.0

    Parameters

    • key: RedisKey
    • Optionalcallback: Callback<null | string>

    Returns Promise<null | string>

  • Parameters

    • key: RedisKey
    • count: string | number
    • Optionalcallback: Callback<string[]>

    Returns Promise<string[]>

  • Parameters

    • key: RedisKey
    • Optionalcallback: Callback<null | Buffer>

    Returns Promise<null | Buffer>

  • Parameters

    • key: RedisKey
    • count: string | number
    • Optionalcallback: Callback<Buffer[]>

    Returns Promise<Buffer[]>

  • Post a message to a shard channel

    • group: pubsub
    • complexity: O(N) where N is the number of clients subscribed to the receiving shard channel.
    • since: 7.0.0

    Parameters

    • shardchannel: string | Buffer
    • message: string | Buffer
    • Optionalcallback: Callback<unknown>

    Returns Promise<unknown>

  • Get one or multiple random members from a set

    • group: set
    • complexity: Without the count argument O(1), otherwise O(N) where N is the absolute value of the passed count.
    • since: 1.0.0

    Parameters

    • key: RedisKey
    • Optionalcallback: Callback<null | string>

    Returns Promise<null | string>

  • Parameters

    • key: RedisKey
    • count: string | number
    • Optionalcallback: Callback<string[]>

    Returns Promise<string[]>

  • Parameters

    • key: RedisKey
    • Optionalcallback: Callback<null | Buffer>

    Returns Promise<null | Buffer>

  • Parameters

    • key: RedisKey
    • count: string | number
    • Optionalcallback: Callback<Buffer[]>

    Returns Promise<Buffer[]>

  • Remove one or more members from a set

    • group: set
    • complexity: O(N) where N is the number of members to be removed.
    • since: 1.0.0

    Parameters

    • Rest...args: [key: RedisKey, ...members: (string | number | Buffer)[], callback: Callback<number>]

    Returns Promise<number>

  • Parameters

    • Rest...args: [key: RedisKey, members: (string | number | Buffer)[], callback: Callback<number>]

    Returns Promise<number>

  • Parameters

    • Rest...args: [key: RedisKey, ...members: (string | number | Buffer)[]]

    Returns Promise<number>

  • Parameters

    • Rest...args: [key: RedisKey, members: (string | number | Buffer)[]]

    Returns Promise<number>

  • Incrementally iterate Set elements

    • group: set
    • complexity: O(1) for every call. O(N) for a complete iteration, including enough command calls for the cursor to return back to 0. N is the number of elements inside the collection..
    • since: 2.8.0

    Parameters

    • key: RedisKey
    • cursor: string | number
    • Optionalcallback: Callback<[cursor: string, elements: string[]]>

    Returns Promise<[cursor: string, elements: string[]]>

  • Parameters

    • key: RedisKey
    • cursor: string | number
    • countToken: "COUNT"
    • count: string | number
    • Optionalcallback: Callback<[cursor: string, elements: string[]]>

    Returns Promise<[cursor: string, elements: string[]]>

  • Parameters

    • key: RedisKey
    • cursor: string | number
    • patternToken: "MATCH"
    • pattern: string
    • Optionalcallback: Callback<[cursor: string, elements: string[]]>

    Returns Promise<[cursor: string, elements: string[]]>

  • Parameters

    • key: RedisKey
    • cursor: string | number
    • patternToken: "MATCH"
    • pattern: string
    • countToken: "COUNT"
    • count: string | number
    • Optionalcallback: Callback<[cursor: string, elements: string[]]>

    Returns Promise<[cursor: string, elements: string[]]>

  • Parameters

    • key: RedisKey
    • cursor: string | number
    • Optionalcallback: Callback<[cursor: Buffer, elements: Buffer[]]>

    Returns Promise<[cursor: Buffer, elements: Buffer[]]>

  • Parameters

    • key: RedisKey
    • cursor: string | number
    • countToken: "COUNT"
    • count: string | number
    • Optionalcallback: Callback<[cursor: Buffer, elements: Buffer[]]>

    Returns Promise<[cursor: Buffer, elements: Buffer[]]>

  • Parameters

    • key: RedisKey
    • cursor: string | number
    • patternToken: "MATCH"
    • pattern: string
    • Optionalcallback: Callback<[cursor: Buffer, elements: Buffer[]]>

    Returns Promise<[cursor: Buffer, elements: Buffer[]]>

  • Parameters

    • key: RedisKey
    • cursor: string | number
    • patternToken: "MATCH"
    • pattern: string
    • countToken: "COUNT"
    • count: string | number
    • Optionalcallback: Callback<[cursor: Buffer, elements: Buffer[]]>

    Returns Promise<[cursor: Buffer, elements: Buffer[]]>

  • Parameters

    • key: string
    • Optionaloptions: ScanStreamOptions

    Returns ScanStream

  • Parameters

    • key: string
    • Optionaloptions: ScanStreamOptions

    Returns ScanStream

  • Listen for messages published to the given shard channels

    • group: pubsub
    • complexity: O(N) where N is the number of shard channels to subscribe to.
    • since: 7.0.0

    Parameters

    • Rest...args: [...shardchannels: (string | Buffer)[], callback: Callback<unknown>]

    Returns Promise<unknown>

  • Parameters

    • Rest...args: (string | Buffer)[]

    Returns Promise<unknown>

  • Get the length of the value stored in a key

    • group: string
    • complexity: O(1)
    • since: 2.2.0

    Parameters

    • key: RedisKey
    • Optionalcallback: Callback<number>

    Returns Promise<number>

  • Listen for messages published to the given channels

    • group: pubsub
    • complexity: O(N) where N is the number of channels to subscribe to.
    • since: 2.0.0

    Parameters

    • Rest...args: [...channels: (string | Buffer)[], callback: Callback<unknown>]

    Returns Promise<unknown>

  • Parameters

    • Rest...args: (string | Buffer)[]

    Returns Promise<unknown>

  • Get a substring of the string stored at a key

    • group: string
    • complexity: O(N) where N is the length of the returned string. The complexity is ultimately determined by the returned length, but because creating a substring from an existing string is very cheap, it can be considered O(1) for small strings.
    • since: 1.0.0

    Parameters

    • key: RedisKey
    • start: string | number
    • end: string | number
    • Optionalcallback: Callback<unknown>

    Returns Promise<unknown>

  • Add multiple sets

    • group: set
    • complexity: O(N) where N is the total number of elements in all given sets.
    • since: 1.0.0

    Parameters

    • Rest...args: [...keys: RedisKey[], callback: Callback<string[]>]

    Returns Promise<string[]>

  • Parameters

    • Rest...args: [keys: RedisKey[], callback: Callback<string[]>]

    Returns Promise<string[]>

  • Parameters

    • Rest...args: RedisKey[]

    Returns Promise<string[]>

  • Parameters

    • Rest...args: [keys: RedisKey[]]

    Returns Promise<string[]>

  • Parameters

    • Rest...args: [...keys: RedisKey[], callback: Callback<Buffer[]>]

    Returns Promise<Buffer[]>

  • Parameters

    • Rest...args: [keys: RedisKey[], callback: Callback<Buffer[]>]

    Returns Promise<Buffer[]>

  • Parameters

    • Rest...args: RedisKey[]

    Returns Promise<Buffer[]>

  • Parameters

    • Rest...args: [keys: RedisKey[]]

    Returns Promise<Buffer[]>

  • Add multiple sets and store the resulting set in a key

    • group: set
    • complexity: O(N) where N is the total number of elements in all given sets.
    • since: 1.0.0

    Parameters

    • Rest...args: [destination: RedisKey, ...keys: RedisKey[], callback: Callback<number>]

    Returns Promise<number>

  • Parameters

    • Rest...args: [destination: RedisKey, keys: RedisKey[], callback: Callback<number>]

    Returns Promise<number>

  • Parameters

    • Rest...args: [destination: RedisKey, ...keys: RedisKey[]]

    Returns Promise<number>

  • Parameters

    • Rest...args: [destination: RedisKey, keys: RedisKey[]]

    Returns Promise<number>

  • Stop listening for messages posted to the given shard channels

    • group: pubsub
    • complexity: O(N) where N is the number of clients already subscribed to a shard channel.
    • since: 7.0.0

    Parameters

    • Optionalcallback: Callback<unknown>

    Returns Promise<unknown>

  • Parameters

    • Rest...args: [...shardchannels: (string | Buffer)[], callback: Callback<unknown>]

    Returns Promise<unknown>

  • Parameters

    • Rest...args: (string | Buffer)[]

    Returns Promise<unknown>

  • Swaps two Redis databases

    • group: server
    • complexity: O(N) where N is the count of clients watching or blocking on keys from both databases.
    • since: 4.0.0

    Parameters

    • index1: string | number
    • index2: string | number
    • Optionalcallback: Callback<"OK">

    Returns Promise<"OK">

  • Internal command used for replication

    • group: server
    • complexity: undefined
    • since: 1.0.0

    Parameters

    • Optionalcallback: Callback<unknown>

    Returns Promise<unknown>

  • Return the current server time

    • group: server
    • complexity: O(1)
    • since: 2.6.0

    Parameters

    • Optionalcallback: Callback<number[]>

    Returns Promise<number[]>

  • Alters the last access time of a key(s). Returns the number of existing keys specified.

    • group: generic
    • complexity: O(N) where N is the number of keys that will be touched.
    • since: 3.2.1

    Parameters

    • Rest...args: [...keys: RedisKey[], callback: Callback<number>]

    Returns Promise<number>

  • Parameters

    • Rest...args: [keys: RedisKey[], callback: Callback<number>]

    Returns Promise<number>

  • Parameters

    • Rest...args: RedisKey[]

    Returns Promise<number>

  • Parameters

    • Rest...args: [keys: RedisKey[]]

    Returns Promise<number>

  • Get the time to live for a key in seconds

    • group: generic
    • complexity: O(1)
    • since: 1.0.0

    Parameters

    • key: RedisKey
    • Optionalcallback: Callback<number>

    Returns Promise<number>

  • Determine the type stored at key

    • group: generic
    • complexity: O(1)
    • since: 1.0.0

    Parameters

    • key: RedisKey
    • Optionalcallback: Callback<string>

    Returns Promise<string>

  • Delete a key asynchronously in another thread. Otherwise it is just as DEL, but non blocking.

    • group: generic
    • complexity: O(1) for each key removed regardless of its size. Then the command does O(N) work in a different thread in order to reclaim memory, where N is the number of allocations the deleted objects where composed of.
    • since: 4.0.0

    Parameters

    • Rest...args: [...keys: RedisKey[], callback: Callback<number>]

    Returns Promise<number>

  • Parameters

    • Rest...args: [keys: RedisKey[], callback: Callback<number>]

    Returns Promise<number>

  • Parameters

    • Rest...args: RedisKey[]

    Returns Promise<number>

  • Parameters

    • Rest...args: [keys: RedisKey[]]

    Returns Promise<number>

  • Stop listening for messages posted to the given channels

    • group: pubsub
    • complexity: O(N) where N is the number of clients already subscribed to a channel.
    • since: 2.0.0

    Parameters

    • Optionalcallback: Callback<unknown>

    Returns Promise<unknown>

  • Parameters

    • Rest...args: [...channels: (string | Buffer)[], callback: Callback<unknown>]

    Returns Promise<unknown>

  • Parameters

    • Rest...args: (string | Buffer)[]

    Returns Promise<unknown>

  • Forget about all watched keys

    • group: transactions
    • complexity: O(1)
    • since: 2.2.0

    Parameters

    • Optionalcallback: Callback<"OK">

    Returns Promise<"OK">

  • Wait for the synchronous replication of all the write commands sent in the context of the current connection

    • group: generic
    • complexity: O(1)
    • since: 3.0.0

    Parameters

    • numreplicas: string | number
    • timeout: string | number
    • Optionalcallback: Callback<number>

    Returns Promise<number>

  • Watch the given keys to determine execution of the MULTI/EXEC block

    • group: transactions
    • complexity: O(1) for every key.
    • since: 2.2.0

    Parameters

    • Rest...args: [...keys: RedisKey[], callback: Callback<"OK">]

    Returns Promise<"OK">

  • Parameters

    • Rest...args: [keys: RedisKey[], callback: Callback<"OK">]

    Returns Promise<"OK">

  • Parameters

    • Rest...args: RedisKey[]

    Returns Promise<"OK">

  • Parameters

    • Rest...args: [keys: RedisKey[]]

    Returns Promise<"OK">

  • Marks a pending message as correctly processed, effectively removing it from the pending entries list of the consumer group. Return value of the command is the number of messages successfully acknowledged, that is, the IDs we were actually able to resolve in the PEL.

    • group: stream
    • complexity: O(1) for each message ID processed.
    • since: 5.0.0

    Parameters

    • Rest...args: [key: RedisKey, group: string | Buffer, ...ids: (string | number | Buffer)[], callback: Callback<number>]

    Returns Promise<number>

  • Parameters

    • Rest...args: [key: RedisKey, group: string | Buffer, ...ids: (string | number | Buffer)[]]

    Returns Promise<number>

  • Appends a new entry to a stream

    • group: stream
    • complexity: O(1) when adding a new entry, O(N) when trimming where N being the number of entries evicted.
    • since: 5.0.0

    Parameters

    • Rest...args: [key: RedisKey, ...args: RedisValue[], callback: Callback<null | string>]

    Returns Promise<null | string>

  • Parameters

    • Rest...args: [key: RedisKey, ...args: RedisValue[]]

    Returns Promise<null | string>

  • Parameters

    • Rest...args: [key: RedisKey, ...args: RedisValue[], callback: Callback<null | Buffer>]

    Returns Promise<null | Buffer>

  • Parameters

    • Rest...args: [key: RedisKey, ...args: RedisValue[]]

    Returns Promise<null | Buffer>

  • Changes (or acquires) ownership of messages in a consumer group, as if the messages were delivered to the specified consumer.

    • group: stream
    • complexity: O(1) if COUNT is small.
    • since: 6.2.0

    Parameters

    • key: RedisKey
    • group: string | Buffer
    • consumer: string | Buffer
    • minIdleTime: string | number | Buffer
    • start: string | number | Buffer
    • Optionalcallback: Callback<unknown[]>

    Returns Promise<unknown[]>

  • Parameters

    • key: RedisKey
    • group: string | Buffer
    • consumer: string | Buffer
    • minIdleTime: string | number | Buffer
    • start: string | number | Buffer
    • justid: "JUSTID"
    • Optionalcallback: Callback<unknown[]>

    Returns Promise<unknown[]>

  • Parameters

    • key: RedisKey
    • group: string | Buffer
    • consumer: string | Buffer
    • minIdleTime: string | number | Buffer
    • start: string | number | Buffer
    • countToken: "COUNT"
    • count: string | number
    • Optionalcallback: Callback<unknown[]>

    Returns Promise<unknown[]>

  • Parameters

    • key: RedisKey
    • group: string | Buffer
    • consumer: string | Buffer
    • minIdleTime: string | number | Buffer
    • start: string | number | Buffer
    • countToken: "COUNT"
    • count: string | number
    • justid: "JUSTID"
    • Optionalcallback: Callback<unknown[]>

    Returns Promise<unknown[]>

  • Changes (or acquires) ownership of a message in a consumer group, as if the message was delivered to the specified consumer.

    • group: stream
    • complexity: O(log N) with N being the number of messages in the PEL of the consumer group.
    • since: 5.0.0

    Parameters

    • Rest...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], callback: Callback<unknown[]>]

    Returns Promise<unknown[]>

  • Parameters

    • Rest...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[]]

    Returns Promise<unknown[]>

  • Parameters

    • Rest...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], justid: "JUSTID", callback: Callback<unknown[]>]

    Returns Promise<unknown[]>

  • Parameters

    • Rest...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], justid: "JUSTID"]

    Returns Promise<unknown[]>

  • Parameters

    • Rest...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], force: "FORCE", callback: Callback<unknown[]>]

    Returns Promise<unknown[]>

  • Parameters

    • Rest...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], force: "FORCE"]

    Returns Promise<unknown[]>

  • Parameters

    • Rest...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], force: "FORCE", justid: "JUSTID", callback: Callback<unknown[]>]

    Returns Promise<unknown[]>

  • Parameters

    • Rest...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], force: "FORCE", justid: "JUSTID"]

    Returns Promise<unknown[]>

  • Parameters

    • Rest...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], countToken: "RETRYCOUNT", count: string | number, callback: Callback<unknown[]>]

    Returns Promise<unknown[]>

  • Parameters

    • Rest...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], countToken: "RETRYCOUNT", count: string | number]

    Returns Promise<unknown[]>

  • Parameters

    • Rest...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], countToken: "RETRYCOUNT", count: string | number, justid: "JUSTID", callback: Callback<unknown[]>]

    Returns Promise<unknown[]>

  • Parameters

    • Rest...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], countToken: "RETRYCOUNT", count: string | number, justid: "JUSTID"]

    Returns Promise<unknown[]>

  • Parameters

    • Rest...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], countToken: "RETRYCOUNT", count: string | number, force: "FORCE", callback: Callback<unknown[]>]

    Returns Promise<unknown[]>

  • Parameters

    • Rest...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], countToken: "RETRYCOUNT", count: string | number, force: "FORCE"]

    Returns Promise<unknown[]>

  • Parameters

    • Rest...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], countToken: "RETRYCOUNT", count: string | number, force: "FORCE", justid: "JUSTID", callback: Callback<unknown[]>]

    Returns Promise<unknown[]>

  • Parameters

    • Rest...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], countToken: "RETRYCOUNT", count: string | number, force: "FORCE", justid: "JUSTID"]

    Returns Promise<unknown[]>

  • Parameters

    • Rest...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, callback: Callback<unknown[]>]

    Returns Promise<unknown[]>

  • Parameters

    • Rest...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number]

    Returns Promise<unknown[]>

  • Parameters

    • Rest...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, justid: "JUSTID", callback: Callback<unknown[]>]

    Returns Promise<unknown[]>

  • Parameters

    • Rest...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, justid: "JUSTID"]

    Returns Promise<unknown[]>

  • Parameters

    • Rest...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, force: "FORCE", callback: Callback<unknown[]>]

    Returns Promise<unknown[]>

  • Parameters

    • Rest...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, force: "FORCE"]

    Returns Promise<unknown[]>

  • Parameters

    • Rest...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, force: "FORCE", justid: "JUSTID", callback: Callback<unknown[]>]

    Returns Promise<unknown[]>

  • Parameters

    • Rest...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, force: "FORCE", justid: "JUSTID"]

    Returns Promise<unknown[]>

  • Parameters

    • Rest...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, countToken: "RETRYCOUNT", count: string | number, callback: Callback<unknown[]>]

    Returns Promise<unknown[]>

  • Parameters

    • Rest...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, countToken: "RETRYCOUNT", count: string | number]

    Returns Promise<unknown[]>

  • Parameters

    • Rest...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, countToken: "RETRYCOUNT", count: string | number, justid: "JUSTID", callback: Callback<unknown[]>]

    Returns Promise<unknown[]>

  • Parameters

    • Rest...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, countToken: "RETRYCOUNT", count: string | number, justid: "JUSTID"]

    Returns Promise<unknown[]>

  • Parameters

    • Rest...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, countToken: "RETRYCOUNT", count: string | number, force: "FORCE", callback: Callback<unknown[]>]

    Returns Promise<unknown[]>

  • Parameters

    • Rest...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, countToken: "RETRYCOUNT", count: string | number, force: "FORCE"]

    Returns Promise<unknown[]>

  • Parameters

    • Rest...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, countToken: "RETRYCOUNT", count: string | number]

    Returns Promise<unknown[]>

  • Parameters

    • Rest...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, countToken: "RETRYCOUNT", count: string | number, force: "FORCE", justid: "JUSTID"]

    Returns Promise<unknown[]>

  • Parameters

    • Rest...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, callback: Callback<unknown[]>]

    Returns Promise<unknown[]>

  • Parameters

    • Rest...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number]

    Returns Promise<unknown[]>

  • Parameters

    • Rest...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, justid: "JUSTID", callback: Callback<unknown[]>]

    Returns Promise<unknown[]>

  • Parameters

    • Rest...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, justid: "JUSTID"]

    Returns Promise<unknown[]>

  • Parameters

    • Rest...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, force: "FORCE", callback: Callback<unknown[]>]

    Returns Promise<unknown[]>

  • Parameters

    • Rest...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, force: "FORCE"]

    Returns Promise<unknown[]>

  • Parameters

    • Rest...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, force: "FORCE", justid: "JUSTID", callback: Callback<unknown[]>]

    Returns Promise<unknown[]>

  • Parameters

    • Rest...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, force: "FORCE", justid: "JUSTID"]

    Returns Promise<unknown[]>

  • Parameters

    • Rest...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, countToken: "RETRYCOUNT", count: string | number, callback: Callback<unknown[]>]

    Returns Promise<unknown[]>

  • Parameters

    • Rest...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, countToken: "RETRYCOUNT", count: string | number]

    Returns Promise<unknown[]>

  • Parameters

    • Rest...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, countToken: "RETRYCOUNT", count: string | number, justid: "JUSTID", callback: Callback<unknown[]>]

    Returns Promise<unknown[]>

  • Parameters

    • Rest...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, countToken: "RETRYCOUNT", count: string | number, justid: "JUSTID"]

    Returns Promise<unknown[]>

  • Parameters

    • Rest...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, countToken: "RETRYCOUNT", count: string | number, force: "FORCE", callback: Callback<unknown[]>]

    Returns Promise<unknown[]>

  • Parameters

    • Rest...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, countToken: "RETRYCOUNT", count: string | number, force: "FORCE"]

    Returns Promise<unknown[]>

  • Parameters

    • Rest...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, countToken: "RETRYCOUNT", count: string | number]

    Returns Promise<unknown[]>

  • Parameters

    • Rest...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, countToken: "RETRYCOUNT", count: string | number, force: "FORCE", justid: "JUSTID"]

    Returns Promise<unknown[]>

  • Parameters

    • Rest...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, callback: Callback<unknown[]>]

    Returns Promise<unknown[]>

  • Parameters

    • Rest...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number]

    Returns Promise<unknown[]>

  • Parameters

    • Rest...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, justid: "JUSTID", callback: Callback<unknown[]>]

    Returns Promise<unknown[]>

  • Parameters

    • Rest...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, justid: "JUSTID"]

    Returns Promise<unknown[]>

  • Parameters

    • Rest...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, force: "FORCE", callback: Callback<unknown[]>]

    Returns Promise<unknown[]>

  • Parameters

    • Rest...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, force: "FORCE"]

    Returns Promise<unknown[]>

  • Parameters

    • Rest...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number]

    Returns Promise<unknown[]>

  • Parameters

    • Rest...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, force: "FORCE", justid: "JUSTID"]

    Returns Promise<unknown[]>

  • Parameters

    • Rest...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number]

    Returns Promise<unknown[]>

  • Parameters

    • Rest...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number, countToken: "RETRYCOUNT", count: string | number]

    Returns Promise<unknown[]>

  • Parameters

    • Rest...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number]

    Returns Promise<unknown[]>

  • Parameters

    • Rest...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number]

    Returns Promise<unknown[]>

  • Parameters

    • Rest...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number]

    Returns Promise<unknown[]>

  • Parameters

    • Rest...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number]

    Returns Promise<unknown[]>

  • Parameters

    • Rest...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number]

    Returns Promise<unknown[]>

  • Parameters

    • Rest...args: [key: RedisKey, group: string | Buffer, consumer: string | Buffer, minIdleTime: string | number | Buffer, ...ids: (string | number | Buffer)[], msToken: "IDLE", ms: string | number, unixTimeMillisecondsToken: "TIME", unixTimeMilliseconds: string | number]

    Returns Promise<unknown[]>

  • Removes the specified entries from the stream. Returns the number of items actually deleted, that may be different from the number of IDs passed in case certain IDs do not exist.

    • group: stream
    • complexity: O(1) for each single item to delete in the stream, regardless of the stream size.
    • since: 5.0.0

    Parameters

    • Rest...args: [key: RedisKey, ...ids: (string | number | Buffer)[], callback: Callback<number>]

    Returns Promise<number>

  • Parameters

    • Rest...args: [key: RedisKey, ...ids: (string | number | Buffer)[]]

    Returns Promise<number>

  • Create a consumer group.

    • group: stream
    • complexity: O(1)
    • since: 5.0.0

    Parameters

    • subcommand: "CREATE"
    • key: RedisKey
    • groupname: string | Buffer
    • id: string | number | Buffer
    • Optionalcallback: Callback<unknown>

    Returns Promise<unknown>

  • Parameters

    • subcommand: "CREATE"
    • key: RedisKey
    • groupname: string | Buffer
    • id: string | number | Buffer
    • entriesReadToken: "ENTRIESREAD"
    • entriesRead: string | number
    • Optionalcallback: Callback<unknown>

    Returns Promise<unknown>

  • Parameters

    • subcommand: "CREATE"
    • key: RedisKey
    • groupname: string | Buffer
    • id: string | number | Buffer
    • mkstream: "MKSTREAM"
    • Optionalcallback: Callback<unknown>

    Returns Promise<unknown>

  • Parameters

    • subcommand: "CREATE"
    • key: RedisKey
    • groupname: string | Buffer
    • id: string | number | Buffer
    • mkstream: "MKSTREAM"
    • entriesReadToken: "ENTRIESREAD"
    • entriesRead: string | number
    • Optionalcallback: Callback<unknown>

    Returns Promise<unknown>

  • Parameters

    • subcommand: "CREATE"
    • key: RedisKey
    • groupname: string | Buffer
    • newId: "$"
    • Optionalcallback: Callback<unknown>

    Returns Promise<unknown>

  • Parameters

    • subcommand: "CREATE"
    • key: RedisKey
    • groupname: string | Buffer
    • newId: "$"
    • entriesReadToken: "ENTRIESREAD"
    • entriesRead: string | number
    • Optionalcallback: Callback<unknown>

    Returns Promise<unknown>

  • Parameters

    • subcommand: "CREATE"
    • key: RedisKey
    • groupname: string | Buffer
    • newId: "$"
    • mkstream: "MKSTREAM"
    • Optionalcallback: Callback<unknown>

    Returns Promise<unknown>

  • Parameters

    • subcommand: "CREATE"
    • key: RedisKey
    • groupname: string | Buffer
    • newId: "$"
    • mkstream: "MKSTREAM"
    • entriesReadToken: "ENTRIESREAD"
    • entriesRead: string | number
    • Optionalcallback: Callback<unknown>

    Returns Promise<unknown>

  • Create a consumer in a consumer group.

    • group: stream
    • complexity: O(1)
    • since: 6.2.0

    Parameters

    • subcommand: "CREATECONSUMER"
    • key: RedisKey
    • groupname: string | Buffer
    • consumername: string | Buffer
    • Optionalcallback: Callback<unknown>

    Returns Promise<unknown>

  • Delete a consumer from a consumer group.

    • group: stream
    • complexity: O(1)
    • since: 5.0.0

    Parameters

    • subcommand: "DELCONSUMER"
    • key: RedisKey
    • groupname: string | Buffer
    • consumername: string | Buffer
    • Optionalcallback: Callback<unknown>

    Returns Promise<unknown>

  • Destroy a consumer group.

    • group: stream
    • complexity: O(N) where N is the number of entries in the group's pending entries list (PEL).
    • since: 5.0.0

    Parameters

    • subcommand: "DESTROY"
    • key: RedisKey
    • groupname: string | Buffer
    • Optionalcallback: Callback<unknown>

    Returns Promise<unknown>

  • Show helpful text about the different subcommands

    • group: stream
    • complexity: O(1)
    • since: 5.0.0

    Parameters

    • subcommand: "HELP"
    • Optionalcallback: Callback<unknown>

    Returns Promise<unknown>

  • Set a consumer group to an arbitrary last delivered ID value.

    • group: stream
    • complexity: O(1)
    • since: 5.0.0

    Parameters

    • subcommand: "SETID"
    • key: RedisKey
    • groupname: string | Buffer
    • id: string | number | Buffer
    • Optionalcallback: Callback<unknown>

    Returns Promise<unknown>

  • Parameters

    • subcommand: "SETID"
    • key: RedisKey
    • groupname: string | Buffer
    • id: string | number | Buffer
    • entriesReadToken: "ENTRIESREAD"
    • entriesRead: string | number
    • Optionalcallback: Callback<unknown>

    Returns Promise<unknown>

  • Parameters

    • subcommand: "SETID"
    • key: RedisKey
    • groupname: string | Buffer
    • newId: "$"
    • Optionalcallback: Callback<unknown>

    Returns Promise<unknown>

  • Parameters

    • subcommand: "SETID"
    • key: RedisKey
    • groupname: string | Buffer
    • newId: "$"
    • entriesReadToken: "ENTRIESREAD"
    • entriesRead: string | number
    • Optionalcallback: Callback<unknown>

    Returns Promise<unknown>

  • List the consumers in a consumer group

    • group: stream
    • complexity: O(1)
    • since: 5.0.0

    Parameters

    • subcommand: "CONSUMERS"
    • key: RedisKey
    • groupname: string | Buffer
    • Optionalcallback: Callback<unknown>

    Returns Promise<unknown>

  • List the consumer groups of a stream

    • group: stream
    • complexity: O(1)
    • since: 5.0.0

    Parameters

    • subcommand: "GROUPS"
    • key: RedisKey
    • Optionalcallback: Callback<unknown>

    Returns Promise<unknown>

  • Show helpful text about the different subcommands

    • group: stream
    • complexity: O(1)
    • since: 5.0.0

    Parameters

    • subcommand: "HELP"
    • Optionalcallback: Callback<unknown>

    Returns Promise<unknown>

  • Get information about a stream

    • group: stream
    • complexity: O(1)
    • since: 5.0.0

    Parameters

    • subcommand: "STREAM"
    • key: RedisKey
    • Optionalcallback: Callback<unknown>

    Returns Promise<unknown>

  • Parameters

    • subcommand: "STREAM"
    • key: RedisKey
    • fullToken: "FULL"
    • Optionalcallback: Callback<unknown>

    Returns Promise<unknown>

  • Parameters

    • subcommand: "STREAM"
    • key: RedisKey
    • fullToken: "FULL"
    • countToken: "COUNT"
    • count: string | number
    • Optionalcallback: Callback<unknown>

    Returns Promise<unknown>

  • Return the number of entries in a stream

    • group: stream
    • complexity: O(1)
    • since: 5.0.0

    Parameters

    • key: RedisKey
    • Optionalcallback: Callback<number>

    Returns Promise<number>

  • Return information and entries from a stream consumer group pending entries list, that are messages fetched but never acknowledged.

    • group: stream
    • complexity: O(N) with N being the number of elements returned, so asking for a small fixed number of entries per call is O(1). O(M), where M is the total number of entries scanned when used with the IDLE filter. When the command returns just the summary and the list of consumers is small, it runs in O(1) time; otherwise, an additional O(N) time for iterating every consumer.
    • since: 5.0.0

    Parameters

    • key: RedisKey
    • group: string | Buffer
    • Optionalcallback: Callback<unknown[]>

    Returns Promise<unknown[]>

  • Parameters

    • key: RedisKey
    • group: string | Buffer
    • start: string | number | Buffer
    • end: string | number | Buffer
    • count: string | number
    • Optionalcallback: Callback<unknown[]>

    Returns Promise<unknown[]>

  • Parameters

    • key: RedisKey
    • group: string | Buffer
    • start: string | number | Buffer
    • end: string | number | Buffer
    • count: string | number
    • consumer: string | Buffer
    • Optionalcallback: Callback<unknown[]>

    Returns Promise<unknown[]>

  • Parameters

    • key: RedisKey
    • group: string | Buffer
    • minIdleTimeToken: "IDLE"
    • minIdleTime: string | number
    • start: string | number | Buffer
    • end: string | number | Buffer
    • count: string | number
    • Optionalcallback: Callback<unknown[]>

    Returns Promise<unknown[]>

  • Parameters

    • key: RedisKey
    • group: string | Buffer
    • minIdleTimeToken: "IDLE"
    • minIdleTime: string | number
    • start: string | number | Buffer
    • end: string | number | Buffer
    • count: string | number
    • consumer: string | Buffer
    • Optionalcallback: Callback<unknown[]>

    Returns Promise<unknown[]>

  • Return a range of elements in a stream, with IDs matching the specified IDs interval

    • group: stream
    • complexity: O(N) with N being the number of elements being returned. If N is constant (e.g. always asking for the first 10 elements with COUNT), you can consider it O(1).
    • since: 5.0.0

    Parameters

    • key: RedisKey
    • start: string | number | Buffer
    • end: string | number | Buffer
    • Optionalcallback: Callback<[id: string, fields: string[]][]>

    Returns Promise<[id: string, fields: string[]][]>

  • Parameters

    • key: RedisKey
    • start: string | number | Buffer
    • end: string | number | Buffer
    • countToken: "COUNT"
    • count: string | number
    • Optionalcallback: Callback<[id: string, fields: string[]][]>

    Returns Promise<[id: string, fields: string[]][]>

  • Parameters

    • key: RedisKey
    • start: string | number | Buffer
    • end: string | number | Buffer
    • Optionalcallback: Callback<[id: Buffer, fields: Buffer[]][]>

    Returns Promise<[id: Buffer, fields: Buffer[]][]>

  • Parameters

    • key: RedisKey
    • start: string | number | Buffer
    • end: string | number | Buffer
    • countToken: "COUNT"
    • count: string | number
    • Optionalcallback: Callback<[id: Buffer, fields: Buffer[]][]>

    Returns Promise<[id: Buffer, fields: Buffer[]][]>

  • Return never seen elements in multiple streams, with IDs greater than the ones reported by the caller for each stream. Can block.

    • group: stream
    • complexity: For each stream mentioned: O(N) with N being the number of elements being returned, it means that XREAD-ing with a fixed COUNT is O(1). Note that when the BLOCK option is used, XADD will pay O(M) time in order to serve the M clients blocked on the stream getting new data.
    • since: 5.0.0

    Parameters

    • Rest...args: [streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<null | [key: string, items: [id: string, fields: string[]][]][]>]

    Returns Promise<null | [key: string, items: [id: string, fields: string[]][]][]>

  • Parameters

    • Rest...args: [streamsToken: "STREAMS", ...args: RedisValue[]]

    Returns Promise<null | [key: string, items: [id: string, fields: string[]][]][]>

  • Parameters

    • Rest...args: [millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<null | [key: string, items: [id: string, fields: string[]][]][]>]

    Returns Promise<null | [key: string, items: [id: string, fields: string[]][]][]>

  • Parameters

    • Rest...args: [millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]

    Returns Promise<null | [key: string, items: [id: string, fields: string[]][]][]>

  • Parameters

    • Rest...args: [countToken: "COUNT", count: string | number, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<null | [key: string, items: [id: string, fields: string[]][]][]>]

    Returns Promise<null | [key: string, items: [id: string, fields: string[]][]][]>

  • Parameters

    • Rest...args: [countToken: "COUNT", count: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]

    Returns Promise<null | [key: string, items: [id: string, fields: string[]][]][]>

  • Parameters

    • Rest...args: [countToken: "COUNT", count: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<null | [key: string, items: [id: string, fields: string[]][]][]>]

    Returns Promise<null | [key: string, items: [id: string, fields: string[]][]][]>

  • Parameters

    • Rest...args: [countToken: "COUNT", count: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]

    Returns Promise<null | [key: string, items: [id: string, fields: string[]][]][]>

  • Parameters

    • Rest...args: [streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<null | [key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>]

    Returns Promise<null | [key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>

  • Parameters

    • Rest...args: [streamsToken: "STREAMS", ...args: RedisValue[]]

    Returns Promise<null | [key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>

  • Parameters

    • Rest...args: [millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<null | [key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>]

    Returns Promise<null | [key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>

  • Parameters

    • Rest...args: [millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]

    Returns Promise<null | [key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>

  • Parameters

    • Rest...args: [countToken: "COUNT", count: string | number, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<null | [key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>]

    Returns Promise<null | [key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>

  • Parameters

    • Rest...args: [countToken: "COUNT", count: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]

    Returns Promise<null | [key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>

  • Parameters

    • Rest...args: [countToken: "COUNT", count: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<null | [key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>]

    Returns Promise<null | [key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>

  • Parameters

    • Rest...args: [countToken: "COUNT", count: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]

    Returns Promise<null | [key: Buffer, items: [id: Buffer, fields: Buffer[]][]][]>

  • Return new entries from a stream using a consumer group, or access the history of the pending entries for a given consumer. Can block.

    • group: stream
    • complexity: For each stream mentioned: O(M) with M being the number of elements returned. If M is constant (e.g. always asking for the first 10 elements with COUNT), you can consider it O(1). On the other side when XREADGROUP blocks, XADD will pay the O(N) time in order to serve the N clients blocked on the stream getting new data.
    • since: 5.0.0

    Parameters

    • Rest...args: [groupConsumerToken: "GROUP", group: string | Buffer, consumer: string | Buffer, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<unknown[]>]

    Returns Promise<unknown[]>

  • Parameters

    • Rest...args: [groupConsumerToken: "GROUP", group: string | Buffer, consumer: string | Buffer, streamsToken: "STREAMS", ...args: RedisValue[]]

    Returns Promise<unknown[]>

  • Parameters

    • Rest...args: [groupConsumerToken: "GROUP", group: string | Buffer, consumer: string | Buffer, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<unknown[]>]

    Returns Promise<unknown[]>

  • Parameters

    • Rest...args: [groupConsumerToken: "GROUP", group: string | Buffer, consumer: string | Buffer, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[]]

    Returns Promise<unknown[]>

  • Parameters

    • Rest...args: [groupConsumerToken: "GROUP", group: string | Buffer, consumer: string | Buffer, millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<unknown[]>]

    Returns Promise<unknown[]>

  • Parameters

    • Rest...args: [groupConsumerToken: "GROUP", group: string | Buffer, consumer: string | Buffer, millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]

    Returns Promise<unknown[]>

  • Parameters

    • Rest...args: [groupConsumerToken: "GROUP", group: string | Buffer, consumer: string | Buffer, millisecondsToken: "BLOCK", milliseconds: string | number, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<unknown[]>]

    Returns Promise<unknown[]>

  • Parameters

    • Rest...args: [groupConsumerToken: "GROUP", group: string | Buffer, consumer: string | Buffer, millisecondsToken: "BLOCK", milliseconds: string | number, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[]]

    Returns Promise<unknown[]>

  • Parameters

    • Rest...args: [groupConsumerToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<unknown[]>]

    Returns Promise<unknown[]>

  • Parameters

    • Rest...args: [groupConsumerToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]

    Returns Promise<unknown[]>

  • Parameters

    • Rest...args: [groupConsumerToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<unknown[]>]

    Returns Promise<unknown[]>

  • Parameters

    • Rest...args: [groupConsumerToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[]]

    Returns Promise<unknown[]>

  • Parameters

    • Rest...args: [groupConsumerToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<unknown[]>]

    Returns Promise<unknown[]>

  • Parameters

    • Rest...args: [groupConsumerToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, streamsToken: "STREAMS", ...args: RedisValue[]]

    Returns Promise<unknown[]>

  • Parameters

    • Rest...args: [groupConsumerToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[], callback: Callback<unknown[]>]

    Returns Promise<unknown[]>

  • Parameters

    • Rest...args: [groupConsumerToken: "GROUP", group: string | Buffer, consumer: string | Buffer, countToken: "COUNT", count: string | number, millisecondsToken: "BLOCK", milliseconds: string | number, noack: "NOACK", streamsToken: "STREAMS", ...args: RedisValue[]]

    Returns Promise<unknown[]>

  • Return a range of elements in a stream, with IDs matching the specified IDs interval, in reverse order (from greater to smaller IDs) compared to XRANGE

    • group: stream
    • complexity: O(N) with N being the number of elements returned. If N is constant (e.g. always asking for the first 10 elements with COUNT), you can consider it O(1).
    • since: 5.0.0

    Parameters

    • key: RedisKey
    • end: string | number | Buffer
    • start: string | number | Buffer
    • Optionalcallback: Callback<[id: string, fields: string[]][]>

    Returns Promise<[id: string, fields: string[]][]>

  • Parameters

    • key: RedisKey
    • end: string | number | Buffer
    • start: string | number | Buffer
    • countToken: "COUNT"
    • count: string | number
    • Optionalcallback: Callback<[id: string, fields: string[]][]>

    Returns Promise<[id: string, fields: string[]][]>

  • Parameters

    • key: RedisKey
    • end: string | number | Buffer
    • start: string | number | Buffer
    • Optionalcallback: Callback<[id: Buffer, fields: Buffer[]][]>

    Returns Promise<[id: Buffer, fields: Buffer[]][]>

  • Parameters

    • key: RedisKey
    • end: string | number | Buffer
    • start: string | number | Buffer
    • countToken: "COUNT"
    • count: string | number
    • Optionalcallback: Callback<[id: Buffer, fields: Buffer[]][]>

    Returns Promise<[id: Buffer, fields: Buffer[]][]>

  • An internal command for replicating stream values

    • group: stream
    • complexity: O(1)
    • since: 5.0.0

    Parameters

    • key: RedisKey
    • lastId: string | number | Buffer
    • Optionalcallback: Callback<unknown>

    Returns Promise<unknown>

  • Parameters

    • key: RedisKey
    • lastId: string | number | Buffer
    • maxDeletedEntryIdToken: "MAXDELETEDID"
    • maxDeletedEntryId: string | number | Buffer
    • Optionalcallback: Callback<unknown>

    Returns Promise<unknown>

  • Parameters

    • key: RedisKey
    • lastId: string | number | Buffer
    • entriesAddedToken: "ENTRIESADDED"
    • entriesAdded: string | number
    • Optionalcallback: Callback<unknown>

    Returns Promise<unknown>

  • Parameters

    • key: RedisKey
    • lastId: string | number | Buffer
    • entriesAddedToken: "ENTRIESADDED"
    • entriesAdded: string | number
    • maxDeletedEntryIdToken: "MAXDELETEDID"
    • maxDeletedEntryId: string | number | Buffer
    • Optionalcallback: Callback<unknown>

    Returns Promise<unknown>

  • Trims the stream to (approximately if '~' is passed) a certain size

    • group: stream
    • complexity: O(N), with N being the number of evicted entries. Constant times are very small however, since entries are organized in macro nodes containing multiple entries that can be released with a single deallocation.
    • since: 5.0.0

    Parameters

    • key: RedisKey
    • maxlen: "MAXLEN"
    • threshold: string | number | Buffer
    • Optionalcallback: Callback<number>

    Returns Promise<number>

  • Parameters

    • key: RedisKey
    • maxlen: "MAXLEN"
    • threshold: string | number | Buffer
    • countToken: "LIMIT"
    • count: string | number
    • Optionalcallback: Callback<number>

    Returns Promise<number>

  • Parameters

    • key: RedisKey
    • maxlen: "MAXLEN"
    • equal: "="
    • threshold: string | number | Buffer
    • Optionalcallback: Callback<number>

    Returns Promise<number>

  • Parameters

    • key: RedisKey
    • maxlen: "MAXLEN"
    • equal: "="
    • threshold: string | number | Buffer
    • countToken: "LIMIT"
    • count: string | number
    • Optionalcallback: Callback<number>

    Returns Promise<number>

  • Parameters

    • key: RedisKey
    • maxlen: "MAXLEN"
    • approximately: "~"
    • threshold: string | number | Buffer
    • Optionalcallback: Callback<number>

    Returns Promise<number>

  • Parameters

    • key: RedisKey
    • maxlen: "MAXLEN"
    • approximately: "~"
    • threshold: string | number | Buffer
    • countToken: "LIMIT"
    • count: string | number
    • Optionalcallback: Callback<number>

    Returns Promise<number>

  • Parameters

    • key: RedisKey
    • minid: "MINID"
    • threshold: string | number | Buffer
    • Optionalcallback: Callback<number>

    Returns Promise<number>

  • Parameters

    • key: RedisKey
    • minid: "MINID"
    • threshold: string | number | Buffer
    • countToken: "LIMIT"
    • count: string | number
    • Optionalcallback: Callback<number>

    Returns Promise<number>

  • Parameters

    • key: RedisKey
    • minid: "MINID"
    • equal: "="
    • threshold: string | number | Buffer
    • Optionalcallback: Callback<number>

    Returns Promise<number>

  • Parameters

    • key: RedisKey
    • minid: "MINID"
    • equal: "="
    • threshold: string | number | Buffer
    • countToken: "LIMIT"
    • count: string | number
    • Optionalcallback: Callback<number>

    Returns Promise<number>

  • Parameters

    • key: RedisKey
    • minid: "MINID"
    • approximately: "~"
    • threshold: string | number | Buffer
    • Optionalcallback: Callback<number>

    Returns Promise<number>

  • Parameters

    • key: RedisKey
    • minid: "MINID"
    • approximately: "~"
    • threshold: string | number | Buffer
    • countToken: "LIMIT"
    • count: string | number
    • Optionalcallback: Callback<number>

    Returns Promise<number>

  • Add one or more members to a sorted set, or update its score if it already exists

    • group: sorted-set
    • complexity: O(log(N)) for each item added, where N is the number of elements in the sorted set.
    • since: 1.2.0

    Parameters

    • Rest...args: [key: RedisKey, ...scoreMembers: (string | number | Buffer)[], callback: Callback<number>]

    Returns Promise<number>

  • Parameters

    • Rest...args: [key: RedisKey, ...scoreMembers: (string | number | Buffer)[]]

    Returns Promise<number>

  • Parameters

    • Rest...args: [key: RedisKey, incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<string>]

    Returns Promise<string>

  • Parameters

    • Rest...args: [key: RedisKey, incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]

    Returns Promise<string>

  • Parameters

    • Rest...args: [key: RedisKey, ch: "CH", ...scoreMembers: (string | number | Buffer)[], callback: Callback<number>]

    Returns Promise<number>

  • Parameters

    • Rest...args: [key: RedisKey, ch: "CH", ...scoreMembers: (string | number | Buffer)[]]

    Returns Promise<number>

  • Parameters

    • Rest...args: [key: RedisKey, ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<string>]

    Returns Promise<string>

  • Parameters

    • Rest...args: [key: RedisKey, ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]

    Returns Promise<string>

  • Parameters

    • Rest...args: [key: RedisKey, gt: "GT", ...scoreMembers: (string | number | Buffer)[], callback: Callback<number>]

    Returns Promise<number>

  • Parameters

    • Rest...args: [key: RedisKey, gt: "GT", ...scoreMembers: (string | number | Buffer)[]]

    Returns Promise<number>

  • Parameters

    • Rest...args: [key: RedisKey, gt: "GT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<string>]

    Returns Promise<string>

  • Parameters

    • Rest...args: [key: RedisKey, gt: "GT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]

    Returns Promise<string>

  • Parameters

    • Rest...args: [key: RedisKey, gt: "GT", ch: "CH", ...scoreMembers: (string | number | Buffer)[], callback: Callback<number>]

    Returns Promise<number>

  • Parameters

    • Rest...args: [key: RedisKey, gt: "GT", ch: "CH", ...scoreMembers: (string | number | Buffer)[]]

    Returns Promise<number>

  • Parameters

    • Rest...args: [key: RedisKey, gt: "GT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<string>]

    Returns Promise<string>

  • Parameters

    • Rest...args: [key: RedisKey, gt: "GT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]

    Returns Promise<string>

  • Parameters

    • Rest...args: [key: RedisKey, lt: "LT", ...scoreMembers: (string | number | Buffer)[], callback: Callback<number>]

    Returns Promise<number>

  • Parameters

    • Rest...args: [key: RedisKey, lt: "LT", ...scoreMembers: (string | number | Buffer)[]]

    Returns Promise<number>

  • Parameters

    • Rest...args: [key: RedisKey, lt: "LT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<string>]

    Returns Promise<string>

  • Parameters

    • Rest...args: [key: RedisKey, lt: "LT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]

    Returns Promise<string>

  • Parameters

    • Rest...args: [key: RedisKey, lt: "LT", ch: "CH", ...scoreMembers: (string | number | Buffer)[], callback: Callback<number>]

    Returns Promise<number>

  • Parameters

    • Rest...args: [key: RedisKey, lt: "LT", ch: "CH", ...scoreMembers: (string | number | Buffer)[]]

    Returns Promise<number>

  • Parameters

    • Rest...args: [key: RedisKey, lt: "LT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<string>]

    Returns Promise<string>

  • Parameters

    • Rest...args: [key: RedisKey, lt: "LT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]

    Returns Promise<string>

  • Parameters

    • Rest...args: [key: RedisKey, nx: "NX", ...scoreMembers: (string | number | Buffer)[], callback: Callback<number>]

    Returns Promise<number>

  • Parameters

    • Rest...args: [key: RedisKey, nx: "NX", ...scoreMembers: (string | number | Buffer)[]]

    Returns Promise<number>

  • Parameters

    • Rest...args: [key: RedisKey, nx: "NX", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<null | string>]

    Returns Promise<null | string>

  • Parameters

    • Rest...args: [key: RedisKey, nx: "NX", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]

    Returns Promise<null | string>

  • Parameters

    • Rest...args: [key: RedisKey, nx: "NX", ch: "CH", ...scoreMembers: (string | number | Buffer)[], callback: Callback<number>]

    Returns Promise<number>

  • Parameters

    • Rest...args: [key: RedisKey, nx: "NX", ch: "CH", ...scoreMembers: (string | number | Buffer)[]]

    Returns Promise<number>

  • Parameters

    • Rest...args: [key: RedisKey, nx: "NX", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<null | string>]

    Returns Promise<null | string>

  • Parameters

    • Rest...args: [key: RedisKey, nx: "NX", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]

    Returns Promise<null | string>

  • Parameters

    • Rest...args: [key: RedisKey, nx: "NX", gt: "GT", ...scoreMembers: (string | number | Buffer)[], callback: Callback<number>]

    Returns Promise<number>

  • Parameters

    • Rest...args: [key: RedisKey, nx: "NX", gt: "GT", ...scoreMembers: (string | number | Buffer)[]]

    Returns Promise<number>

  • Parameters

    • Rest...args: [key: RedisKey, nx: "NX", gt: "GT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<null | string>]

    Returns Promise<null | string>

  • Parameters

    • Rest...args: [key: RedisKey, nx: "NX", gt: "GT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]

    Returns Promise<null | string>

  • Parameters

    • Rest...args: [key: RedisKey, nx: "NX", gt: "GT", ch: "CH", ...scoreMembers: (string | number | Buffer)[], callback: Callback<number>]

    Returns Promise<number>

  • Parameters

    • Rest...args: [key: RedisKey, nx: "NX", gt: "GT", ch: "CH", ...scoreMembers: (string | number | Buffer)[]]

    Returns Promise<number>

  • Parameters

    • Rest...args: [key: RedisKey, nx: "NX", gt: "GT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<null | string>]

    Returns Promise<null | string>

  • Parameters

    • Rest...args: [key: RedisKey, nx: "NX", gt: "GT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]

    Returns Promise<null | string>

  • Parameters

    • Rest...args: [key: RedisKey, nx: "NX", lt: "LT", ...scoreMembers: (string | number | Buffer)[], callback: Callback<number>]

    Returns Promise<number>

  • Parameters

    • Rest...args: [key: RedisKey, nx: "NX", lt: "LT", ...scoreMembers: (string | number | Buffer)[]]

    Returns Promise<number>

  • Parameters

    • Rest...args: [key: RedisKey, nx: "NX", lt: "LT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<null | string>]

    Returns Promise<null | string>

  • Parameters

    • Rest...args: [key: RedisKey, nx: "NX", lt: "LT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]

    Returns Promise<null | string>

  • Parameters

    • Rest...args: [key: RedisKey, nx: "NX", lt: "LT", ch: "CH", ...scoreMembers: (string | number | Buffer)[], callback: Callback<number>]

    Returns Promise<number>

  • Parameters

    • Rest...args: [key: RedisKey, nx: "NX", lt: "LT", ch: "CH", ...scoreMembers: (string | number | Buffer)[]]

    Returns Promise<number>

  • Parameters

    • Rest...args: [key: RedisKey, nx: "NX", lt: "LT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<null | string>]

    Returns Promise<null | string>

  • Parameters

    • Rest...args: [key: RedisKey, nx: "NX", lt: "LT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]

    Returns Promise<null | string>

  • Parameters

    • Rest...args: [key: RedisKey, xx: "XX", ...scoreMembers: (string | number | Buffer)[], callback: Callback<number>]

    Returns Promise<number>

  • Parameters

    • Rest...args: [key: RedisKey, xx: "XX", ...scoreMembers: (string | number | Buffer)[]]

    Returns Promise<number>

  • Parameters

    • Rest...args: [key: RedisKey, xx: "XX", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<null | string>]

    Returns Promise<null | string>

  • Parameters

    • Rest...args: [key: RedisKey, xx: "XX", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]

    Returns Promise<null | string>

  • Parameters

    • Rest...args: [key: RedisKey, xx: "XX", ch: "CH", ...scoreMembers: (string | number | Buffer)[], callback: Callback<number>]

    Returns Promise<number>

  • Parameters

    • Rest...args: [key: RedisKey, xx: "XX", ch: "CH", ...scoreMembers: (string | number | Buffer)[]]

    Returns Promise<number>

  • Parameters

    • Rest...args: [key: RedisKey, xx: "XX", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<null | string>]

    Returns Promise<null | string>

  • Parameters

    • Rest...args: [key: RedisKey, xx: "XX", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]

    Returns Promise<null | string>

  • Parameters

    • Rest...args: [key: RedisKey, xx: "XX", gt: "GT", ...scoreMembers: (string | number | Buffer)[], callback: Callback<number>]

    Returns Promise<number>

  • Parameters

    • Rest...args: [key: RedisKey, xx: "XX", gt: "GT", ...scoreMembers: (string | number | Buffer)[]]

    Returns Promise<number>

  • Parameters

    • Rest...args: [key: RedisKey, xx: "XX", gt: "GT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<null | string>]

    Returns Promise<null | string>

  • Parameters

    • Rest...args: [key: RedisKey, xx: "XX", gt: "GT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]

    Returns Promise<null | string>

  • Parameters

    • Rest...args: [key: RedisKey, xx: "XX", gt: "GT", ch: "CH", ...scoreMembers: (string | number | Buffer)[], callback: Callback<number>]

    Returns Promise<number>

  • Parameters

    • Rest...args: [key: RedisKey, xx: "XX", gt: "GT", ch: "CH", ...scoreMembers: (string | number | Buffer)[]]

    Returns Promise<number>

  • Parameters

    • Rest...args: [key: RedisKey, xx: "XX", gt: "GT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<null | string>]

    Returns Promise<null | string>

  • Parameters

    • Rest...args: [key: RedisKey, xx: "XX", gt: "GT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]

    Returns Promise<null | string>

  • Parameters

    • Rest...args: [key: RedisKey, xx: "XX", lt: "LT", ...scoreMembers: (string | number | Buffer)[], callback: Callback<number>]

    Returns Promise<number>

  • Parameters

    • Rest...args: [key: RedisKey, xx: "XX", lt: "LT", ...scoreMembers: (string | number | Buffer)[]]

    Returns Promise<number>

  • Parameters

    • Rest...args: [key: RedisKey, xx: "XX", lt: "LT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<null | string>]

    Returns Promise<null | string>

  • Parameters

    • Rest...args: [key: RedisKey, xx: "XX", lt: "LT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]

    Returns Promise<null | string>

  • Parameters

    • Rest...args: [key: RedisKey, xx: "XX", lt: "LT", ch: "CH", ...scoreMembers: (string | number | Buffer)[], callback: Callback<number>]

    Returns Promise<number>

  • Parameters

    • Rest...args: [key: RedisKey, xx: "XX", lt: "LT", ch: "CH", ...scoreMembers: (string | number | Buffer)[]]

    Returns Promise<number>

  • Parameters

    • Rest...args: [key: RedisKey, xx: "XX", lt: "LT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<null | string>]

    Returns Promise<null | string>

  • Parameters

    • Rest...args: [key: RedisKey, xx: "XX", lt: "LT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]

    Returns Promise<null | string>

  • Parameters

    • Rest...args: [key: RedisKey, incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<Buffer>]

    Returns Promise<Buffer>

  • Parameters

    • Rest...args: [key: RedisKey, incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]

    Returns Promise<Buffer>

  • Parameters

    • Rest...args: [key: RedisKey, ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<Buffer>]

    Returns Promise<Buffer>

  • Parameters

    • Rest...args: [key: RedisKey, ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]

    Returns Promise<Buffer>

  • Parameters

    • Rest...args: [key: RedisKey, gt: "GT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<Buffer>]

    Returns Promise<Buffer>

  • Parameters

    • Rest...args: [key: RedisKey, gt: "GT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]

    Returns Promise<Buffer>

  • Parameters

    • Rest...args: [key: RedisKey, gt: "GT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<Buffer>]

    Returns Promise<Buffer>

  • Parameters

    • Rest...args: [key: RedisKey, gt: "GT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]

    Returns Promise<Buffer>

  • Parameters

    • Rest...args: [key: RedisKey, lt: "LT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<Buffer>]

    Returns Promise<Buffer>

  • Parameters

    • Rest...args: [key: RedisKey, lt: "LT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]

    Returns Promise<Buffer>

  • Parameters

    • Rest...args: [key: RedisKey, lt: "LT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<Buffer>]

    Returns Promise<Buffer>

  • Parameters

    • Rest...args: [key: RedisKey, lt: "LT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]

    Returns Promise<Buffer>

  • Parameters

    • Rest...args: [key: RedisKey, nx: "NX", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<null | Buffer>]

    Returns Promise<null | Buffer>

  • Parameters

    • Rest...args: [key: RedisKey, nx: "NX", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]

    Returns Promise<null | Buffer>

  • Parameters

    • Rest...args: [key: RedisKey, nx: "NX", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<null | Buffer>]

    Returns Promise<null | Buffer>

  • Parameters

    • Rest...args: [key: RedisKey, nx: "NX", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]

    Returns Promise<null | Buffer>

  • Parameters

    • Rest...args: [key: RedisKey, nx: "NX", gt: "GT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<null | Buffer>]

    Returns Promise<null | Buffer>

  • Parameters

    • Rest...args: [key: RedisKey, nx: "NX", gt: "GT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]

    Returns Promise<null | Buffer>

  • Parameters

    • Rest...args: [key: RedisKey, nx: "NX", gt: "GT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<null | Buffer>]

    Returns Promise<null | Buffer>

  • Parameters

    • Rest...args: [key: RedisKey, nx: "NX", gt: "GT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]

    Returns Promise<null | Buffer>

  • Parameters

    • Rest...args: [key: RedisKey, nx: "NX", lt: "LT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<null | Buffer>]

    Returns Promise<null | Buffer>

  • Parameters

    • Rest...args: [key: RedisKey, nx: "NX", lt: "LT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]

    Returns Promise<null | Buffer>

  • Parameters

    • Rest...args: [key: RedisKey, nx: "NX", lt: "LT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<null | Buffer>]

    Returns Promise<null | Buffer>

  • Parameters

    • Rest...args: [key: RedisKey, nx: "NX", lt: "LT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]

    Returns Promise<null | Buffer>

  • Parameters

    • Rest...args: [key: RedisKey, xx: "XX", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<null | Buffer>]

    Returns Promise<null | Buffer>

  • Parameters

    • Rest...args: [key: RedisKey, xx: "XX", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]

    Returns Promise<null | Buffer>

  • Parameters

    • Rest...args: [key: RedisKey, xx: "XX", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<null | Buffer>]

    Returns Promise<null | Buffer>

  • Parameters

    • Rest...args: [key: RedisKey, xx: "XX", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]

    Returns Promise<null | Buffer>

  • Parameters

    • Rest...args: [key: RedisKey, xx: "XX", gt: "GT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<null | Buffer>]

    Returns Promise<null | Buffer>

  • Parameters

    • Rest...args: [key: RedisKey, xx: "XX", gt: "GT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]

    Returns Promise<null | Buffer>

  • Parameters

    • Rest...args: [key: RedisKey, xx: "XX", gt: "GT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<null | Buffer>]

    Returns Promise<null | Buffer>

  • Parameters

    • Rest...args: [key: RedisKey, xx: "XX", gt: "GT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]

    Returns Promise<null | Buffer>

  • Parameters

    • Rest...args: [key: RedisKey, xx: "XX", lt: "LT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<null | Buffer>]

    Returns Promise<null | Buffer>

  • Parameters

    • Rest...args: [key: RedisKey, xx: "XX", lt: "LT", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]

    Returns Promise<null | Buffer>

  • Parameters

    • Rest...args: [key: RedisKey, xx: "XX", lt: "LT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[], callback: Callback<null | Buffer>]

    Returns Promise<null | Buffer>

  • Parameters

    • Rest...args: [key: RedisKey, xx: "XX", lt: "LT", ch: "CH", incr: "INCR", ...scoreMembers: (string | number | Buffer)[]]

    Returns Promise<null | Buffer>

  • Get the number of members in a sorted set

    • group: sorted-set
    • complexity: O(1)
    • since: 1.2.0

    Parameters

    • key: RedisKey
    • Optionalcallback: Callback<number>

    Returns Promise<number>

  • Count the members in a sorted set with scores within the given values

    • group: sorted-set
    • complexity: O(log(N)) with N being the number of elements in the sorted set.
    • since: 2.0.0

    Parameters

    • key: RedisKey
    • min: string | number
    • max: string | number
    • Optionalcallback: Callback<number>

    Returns Promise<number>

  • Subtract multiple sorted sets

    • group: sorted-set
    • complexity: O(L + (N-K)log(N)) worst case where L is the total number of elements in all the sets, N is the size of the first set, and K is the size of the result set.
    • since: 6.2.0

    Parameters

    • Rest...args: [numkeys: string | number, ...keys: RedisKey[], callback: Callback<string[]>]

    Returns Promise<string[]>

  • Parameters

    • Rest...args: [numkeys: string | number, keys: RedisKey[], callback: Callback<string[]>]

    Returns Promise<string[]>

  • Parameters

    • Rest...args: [numkeys: string | number, ...keys: RedisKey[]]

    Returns Promise<string[]>

  • Parameters

    • Rest...args: [numkeys: string | number, keys: RedisKey[]]

    Returns Promise<string[]>

  • Parameters

    • Rest...args: [numkeys: string | number, ...keys: RedisKey[], withscores: "WITHSCORES", callback: Callback<string[]>]

    Returns Promise<string[]>

  • Parameters

    • Rest...args: [numkeys: string | number, keys: RedisKey[], withscores: "WITHSCORES", callback: Callback<string[]>]

    Returns Promise<string[]>

  • Parameters

    • Rest...args: [numkeys: string | number, ...keys: RedisKey[], withscores: "WITHSCORES"]

    Returns Promise<string[]>

  • Parameters

    • Rest...args: [numkeys: string | number, keys: RedisKey[], withscores: "WITHSCORES"]

    Returns Promise<string[]>

  • Parameters

    • Rest...args: [numkeys: string | number, ...keys: RedisKey[], callback: Callback<Buffer[]>]

    Returns Promise<Buffer[]>

  • Parameters

    • Rest...args: [numkeys: string | number, keys: RedisKey[], callback: Callback<Buffer[]>]

    Returns Promise<Buffer[]>

  • Parameters

    • Rest...args: [numkeys: string | number, ...keys: RedisKey[]]

    Returns Promise<Buffer[]>

  • Parameters

    • Rest...args: [numkeys: string | number, keys: RedisKey[]]

    Returns Promise<Buffer[]>

  • Parameters

    • Rest...args: [numkeys: string | number, ...keys: RedisKey[], withscores: "WITHSCORES", callback: Callback<Buffer[]>]

    Returns Promise<Buffer[]>

  • Parameters

    • Rest...args: [numkeys: string | number, keys: RedisKey[], withscores: "WITHSCORES", callback: Callback<Buffer[]>]

    Returns Promise<Buffer[]>

  • Parameters

    • Rest...args: [numkeys: string | number, ...keys: RedisKey[], withscores: "WITHSCORES"]

    Returns Promise<Buffer[]>

  • Parameters

    • Rest...args: [numkeys: string | number, keys: RedisKey[], withscores: "WITHSCORES"]

    Returns Promise<Buffer[]>

  • Subtract multiple sorted sets and store the resulting sorted set in a new key

    • group: sorted-set
    • complexity: O(L + (N-K)log(N)) worst case where L is the total number of elements in all the sets, N is the size of the first set, and K is the size of the result set.
    • since: 6.2.0

    Parameters

    • Rest...args: [destination: RedisKey, numkeys: string | number, ...keys: RedisKey[], callback: Callback<number>]

    Returns Promise<number>

  • Parameters

    • Rest...args: [destination: RedisKey, numkeys: string | number, keys: RedisKey[], callback: Callback<number>]

    Returns Promise<number>

  • Parameters

    • Rest...args: [destination: RedisKey, numkeys: string | number, ...keys: RedisKey[]]

    Returns Promise<number>

  • Parameters

    • Rest...args: [destination: RedisKey, numkeys: string | number, keys: RedisKey[]]

    Returns Promise<number>

  • Increment the score of a member in a sorted set

    • group: sorted-set
    • complexity: O(log(N)) where N is the number of elements in the sorted set.
    • since: 1.2.0

    Parameters

    • key: RedisKey
    • increment: string | number
    • member: string | number | Buffer
    • Optionalcallback: Callback<string>

    Returns Promise<string>

  • Parameters

    • key: RedisKey
    • increment: string | number
    • member: string | number | Buffer
    • Optionalcallback: Callback<Buffer>

    Returns Promise<Buffer>

  • Intersect multiple sorted sets

    • group: sorted-set
    • complexity: O(NK)+O(Mlog(M)) worst case with N being the smallest input sorted set, K being the number of input sorted sets and M being the number of elements in the resulting sorted set.
    • since: 6.2.0

    Parameters

    • Rest...args: [numkeys: string | number, ...keys: RedisKey[], callback: Callback<string[]>]

    Returns Promise<string[]>

  • Parameters

    • Rest...args: [numkeys: string | number, keys: RedisKey[], callback: Callback<string[]>]

    Returns Promise<string[]>

  • Parameters

    • Rest...args: [numkeys: string | number, ...keys: RedisKey[]]

    Returns Promise<string[]>

  • Parameters

    • Rest...args: [numkeys: string | number, keys: RedisKey[]]

    Returns Promise<string[]>

  • Parameters

    • Rest...args: [numkeys: string | number, ...keys: RedisKey[], withscores: "WITHSCORES", callback: Callback<string[]>]

    Returns Promise<string[]>

  • Parameters

    • Rest...args: [numkeys: string | number, keys: RedisKey[], withscores: "WITHSCORES", callback: Callback<string[]>]

    Returns Promise<string[]>

  • Parameters

    • Rest...args: [numkeys: string | number, ...keys: RedisKey[], withscores: "WITHSCORES"]

    Returns Promise<string[]>

  • Parameters

    • Rest...args: [numkeys: string | number, keys: RedisKey[], withscores: "WITHSCORES"]

    Returns Promise<string[]>

  • Parameters

    • Rest...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<string[]>]

    Returns Promise<string[]>

  • Parameters

    • Rest...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<string[]>]

    Returns Promise<string[]>

  • Parameters

    • Rest...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM"]

    Returns Promise<string[]>

  • Parameters

    • Rest...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM"]

    Returns Promise<string[]>

  • Parameters

    • Rest...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES", callback: Callback<string[]>]

    Returns Promise<string[]>

  • Parameters

    • Rest...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES", callback: Callback<string[]>]

    Returns Promise<string[]>

  • Parameters

    • Rest...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES"]

    Returns Promise<string[]>

  • Parameters

    • Rest...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES"]

    Returns Promise<string[]>

  • Parameters

    • Rest...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", callback: Callback<string[]>]

    Returns Promise<string[]>

  • Parameters

    • Rest...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", callback: Callback<string[]>]

    Returns Promise<string[]>

  • Parameters

    • Rest...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN"]

    Returns Promise<string[]>

  • Parameters

    • Rest...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN"]

    Returns Promise<string[]>

  • Parameters

    • Rest...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES", callback: Callback<string[]>]

    Returns Promise<string[]>

  • Parameters

    • Rest...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES", callback: Callback<string[]>]

    Returns Promise<string[]>

  • Parameters

    • Rest...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES"]

    Returns Promise<string[]>

  • Parameters

    • Rest...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES"]

    Returns Promise<string[]>

  • Parameters

    • Rest...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", callback: Callback<string[]>]

    Returns Promise<string[]>

  • Parameters

    • Rest...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", callback: Callback<string[]>]

    Returns Promise<string[]>

  • Parameters

    • Rest...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX"]

    Returns Promise<string[]>

  • Parameters

    • Rest...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX"]

    Returns Promise<string[]>

  • Parameters

    • Rest...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES", callback: Callback<string[]>]

    Returns Promise<string[]>

  • Parameters

    • Rest...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES", callback: Callback<string[]>]

    Returns Promise<string[]>

  • Parameters

    • Rest...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES"]

    Returns Promise<string[]>

  • Parameters

    • Rest...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES"]

    Returns Promise<string[]>

  • Parameters

    • Rest...args: [numkeys: string | number, ...args: RedisValue[], callback: Callback<string[]>]

    Returns Promise<string[]>

  • Parameters

    • Rest...args: [numkeys: string | number, ...args: RedisValue[]]

    Returns Promise<string[]>

  • Parameters

    • Rest...args: [numkeys: string | number, ...args: RedisValue[], withscores: "WITHSCORES", callback: Callback<string[]>]

    Returns Promise<string[]>

  • Parameters

    • Rest...args: [numkeys: string | number, ...args: RedisValue[], withscores: "WITHSCORES"]

    Returns Promise<string[]>

  • Parameters

    • Rest...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<string[]>]

    Returns Promise<string[]>

  • Parameters

    • Rest...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM"]

    Returns Promise<string[]>

  • Parameters

    • Rest...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES", callback: Callback<string[]>]

    Returns Promise<string[]>

  • Parameters

    • Rest...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES"]

    Returns Promise<string[]>

  • Parameters

    • Rest...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN", callback: Callback<string[]>]

    Returns Promise<string[]>

  • Parameters

    • Rest...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN"]

    Returns Promise<string[]>

  • Parameters

    • Rest...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES", callback: Callback<string[]>]

    Returns Promise<string[]>

  • Parameters

    • Rest...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES"]

    Returns Promise<string[]>

  • Parameters

    • Rest...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX", callback: Callback<string[]>]

    Returns Promise<string[]>

  • Parameters

    • Rest...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX"]

    Returns Promise<string[]>

  • Parameters

    • Rest...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES", callback: Callback<string[]>]

    Returns Promise<string[]>

  • Parameters

    • Rest...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES"]

    Returns Promise<string[]>

  • Parameters

    • Rest...args: [numkeys: string | number, ...keys: RedisKey[], callback: Callback<Buffer[]>]

    Returns Promise<Buffer[]>

  • Parameters

    • Rest...args: [numkeys: string | number, keys: RedisKey[], callback: Callback<Buffer[]>]

    Returns Promise<Buffer[]>

  • Parameters

    • Rest...args: [numkeys: string | number, ...keys: RedisKey[]]

    Returns Promise<Buffer[]>

  • Parameters

    • Rest...args: [numkeys: string | number, keys: RedisKey[]]

    Returns Promise<Buffer[]>

  • Parameters

    • Rest...args: [numkeys: string | number, ...keys: RedisKey[], withscores: "WITHSCORES", callback: Callback<Buffer[]>]

    Returns Promise<Buffer[]>

  • Parameters

    • Rest...args: [numkeys: string | number, keys: RedisKey[], withscores: "WITHSCORES", callback: Callback<Buffer[]>]

    Returns Promise<Buffer[]>

  • Parameters

    • Rest...args: [numkeys: string | number, ...keys: RedisKey[], withscores: "WITHSCORES"]

    Returns Promise<Buffer[]>

  • Parameters

    • Rest...args: [numkeys: string | number, keys: RedisKey[], withscores: "WITHSCORES"]

    Returns Promise<Buffer[]>

  • Parameters

    • Rest...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<Buffer[]>]

    Returns Promise<Buffer[]>

  • Parameters

    • Rest...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<Buffer[]>]

    Returns Promise<Buffer[]>

  • Parameters

    • Rest...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM"]

    Returns Promise<Buffer[]>

  • Parameters

    • Rest...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM"]

    Returns Promise<Buffer[]>

  • Parameters

    • Rest...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES", callback: Callback<Buffer[]>]

    Returns Promise<Buffer[]>

  • Parameters

    • Rest...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES", callback: Callback<Buffer[]>]

    Returns Promise<Buffer[]>

  • Parameters

    • Rest...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES"]

    Returns Promise<Buffer[]>

  • Parameters

    • Rest...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES"]

    Returns Promise<Buffer[]>

  • Parameters

    • Rest...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", callback: Callback<Buffer[]>]

    Returns Promise<Buffer[]>

  • Parameters

    • Rest...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", callback: Callback<Buffer[]>]

    Returns Promise<Buffer[]>

  • Parameters

    • Rest...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN"]

    Returns Promise<Buffer[]>

  • Parameters

    • Rest...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN"]

    Returns Promise<Buffer[]>

  • Parameters

    • Rest...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES", callback: Callback<Buffer[]>]

    Returns Promise<Buffer[]>

  • Parameters

    • Rest...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES", callback: Callback<Buffer[]>]

    Returns Promise<Buffer[]>

  • Parameters

    • Rest...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES"]

    Returns Promise<Buffer[]>

  • Parameters

    • Rest...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES"]

    Returns Promise<Buffer[]>

  • Parameters

    • Rest...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", callback: Callback<Buffer[]>]

    Returns Promise<Buffer[]>

  • Parameters

    • Rest...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", callback: Callback<Buffer[]>]

    Returns Promise<Buffer[]>

  • Parameters

    • Rest...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX"]

    Returns Promise<Buffer[]>

  • Parameters

    • Rest...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX"]

    Returns Promise<Buffer[]>

  • Parameters

    • Rest...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES", callback: Callback<Buffer[]>]

    Returns Promise<Buffer[]>

  • Parameters

    • Rest...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES", callback: Callback<Buffer[]>]

    Returns Promise<Buffer[]>

  • Parameters

    • Rest...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES"]

    Returns Promise<Buffer[]>

  • Parameters

    • Rest...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES"]

    Returns Promise<Buffer[]>

  • Parameters

    • Rest...args: [numkeys: string | number, ...args: RedisValue[], callback: Callback<Buffer[]>]

    Returns Promise<Buffer[]>

  • Parameters

    • Rest...args: [numkeys: string | number, ...args: RedisValue[]]

    Returns Promise<Buffer[]>

  • Parameters

    • Rest...args: [numkeys: string | number, ...args: RedisValue[], withscores: "WITHSCORES", callback: Callback<Buffer[]>]

    Returns Promise<Buffer[]>

  • Parameters

    • Rest...args: [numkeys: string | number, ...args: RedisValue[], withscores: "WITHSCORES"]

    Returns Promise<Buffer[]>

  • Parameters

    • Rest...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<Buffer[]>]

    Returns Promise<Buffer[]>

  • Parameters

    • Rest...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM"]

    Returns Promise<Buffer[]>

  • Parameters

    • Rest...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES", callback: Callback<Buffer[]>]

    Returns Promise<Buffer[]>

  • Parameters

    • Rest...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES"]

    Returns Promise<Buffer[]>

  • Parameters

    • Rest...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN", callback: Callback<Buffer[]>]

    Returns Promise<Buffer[]>

  • Parameters

    • Rest...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN"]

    Returns Promise<Buffer[]>

  • Parameters

    • Rest...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES", callback: Callback<Buffer[]>]

    Returns Promise<Buffer[]>

  • Parameters

    • Rest...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES"]

    Returns Promise<Buffer[]>

  • Parameters

    • Rest...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX", callback: Callback<Buffer[]>]

    Returns Promise<Buffer[]>

  • Parameters

    • Rest...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX"]

    Returns Promise<Buffer[]>

  • Parameters

    • Rest...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES", callback: Callback<Buffer[]>]

    Returns Promise<Buffer[]>

  • Parameters

    • Rest...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES"]

    Returns Promise<Buffer[]>

  • Intersect multiple sorted sets and return the cardinality of the result

    • group: sorted-set
    • complexity: O(N*K) worst case with N being the smallest input sorted set, K being the number of input sorted sets.
    • since: 7.0.0

    Parameters

    • Rest...args: [numkeys: string | number, ...keys: RedisKey[], callback: Callback<number>]

    Returns Promise<number>

  • Parameters

    • Rest...args: [numkeys: string | number, keys: RedisKey[], callback: Callback<number>]

    Returns Promise<number>

  • Parameters

    • Rest...args: [numkeys: string | number, ...keys: RedisKey[]]

    Returns Promise<number>

  • Parameters

    • Rest...args: [numkeys: string | number, keys: RedisKey[]]

    Returns Promise<number>

  • Parameters

    • Rest...args: [numkeys: string | number, ...keys: RedisKey[], limitToken: "LIMIT", limit: string | number, callback: Callback<number>]

    Returns Promise<number>

  • Parameters

    • Rest...args: [numkeys: string | number, keys: RedisKey[], limitToken: "LIMIT", limit: string | number, callback: Callback<number>]

    Returns Promise<number>

  • Parameters

    • Rest...args: [numkeys: string | number, ...keys: RedisKey[], limitToken: "LIMIT", limit: string | number]

    Returns Promise<number>

  • Parameters

    • Rest...args: [numkeys: string | number, keys: RedisKey[], limitToken: "LIMIT", limit: string | number]

    Returns Promise<number>

  • Intersect multiple sorted sets and store the resulting sorted set in a new key

    • group: sorted-set
    • complexity: O(NK)+O(Mlog(M)) worst case with N being the smallest input sorted set, K being the number of input sorted sets and M being the number of elements in the resulting sorted set.
    • since: 2.0.0

    Parameters

    • Rest...args: [destination: RedisKey, numkeys: string | number, ...keys: RedisKey[], callback: Callback<number>]

    Returns Promise<number>

  • Parameters

    • Rest...args: [destination: RedisKey, numkeys: string | number, keys: RedisKey[], callback: Callback<number>]

    Returns Promise<number>

  • Parameters

    • Rest...args: [destination: RedisKey, numkeys: string | number, ...keys: RedisKey[]]

    Returns Promise<number>

  • Parameters

    • Rest...args: [destination: RedisKey, numkeys: string | number, keys: RedisKey[]]

    Returns Promise<number>

  • Parameters

    • Rest...args: [destination: RedisKey, numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<number>]

    Returns Promise<number>

  • Parameters

    • Rest...args: [destination: RedisKey, numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<number>]

    Returns Promise<number>

  • Parameters

    • Rest...args: [destination: RedisKey, numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM"]

    Returns Promise<number>

  • Parameters

    • Rest...args: [destination: RedisKey, numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM"]

    Returns Promise<number>

  • Parameters

    • Rest...args: [destination: RedisKey, numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", callback: Callback<number>]

    Returns Promise<number>

  • Parameters

    • Rest...args: [destination: RedisKey, numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", callback: Callback<number>]

    Returns Promise<number>

  • Parameters

    • Rest...args: [destination: RedisKey, numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN"]

    Returns Promise<number>

  • Parameters

    • Rest...args: [destination: RedisKey, numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN"]

    Returns Promise<number>

  • Parameters

    • Rest...args: [destination: RedisKey, numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", callback: Callback<number>]

    Returns Promise<number>

  • Parameters

    • Rest...args: [destination: RedisKey, numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", callback: Callback<number>]

    Returns Promise<number>

  • Parameters

    • Rest...args: [destination: RedisKey, numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX"]

    Returns Promise<number>

  • Parameters

    • Rest...args: [destination: RedisKey, numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX"]

    Returns Promise<number>

  • Parameters

    • Rest...args: [destination: RedisKey, numkeys: string | number, ...args: RedisValue[], callback: Callback<number>]

    Returns Promise<number>

  • Parameters

    • Rest...args: [destination: RedisKey, numkeys: string | number, ...args: RedisValue[]]

    Returns Promise<number>

  • Parameters

    • Rest...args: [destination: RedisKey, numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<number>]

    Returns Promise<number>

  • Parameters

    • Rest...args: [destination: RedisKey, numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM"]

    Returns Promise<number>

  • Parameters

    • Rest...args: [destination: RedisKey, numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN", callback: Callback<number>]

    Returns Promise<number>

  • Parameters

    • Rest...args: [destination: RedisKey, numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN"]

    Returns Promise<number>

  • Parameters

    • Rest...args: [destination: RedisKey, numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX", callback: Callback<number>]

    Returns Promise<number>

  • Parameters

    • Rest...args: [destination: RedisKey, numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX"]

    Returns Promise<number>

  • Count the number of members in a sorted set between a given lexicographical range

    • group: sorted-set
    • complexity: O(log(N)) with N being the number of elements in the sorted set.
    • since: 2.8.9

    Parameters

    • key: RedisKey
    • min: string | number | Buffer
    • max: string | number | Buffer
    • Optionalcallback: Callback<number>

    Returns Promise<number>

  • Remove and return members with scores in a sorted set

    • group: sorted-set
    • complexity: O(K) + O(N*log(M)) where K is the number of provided keys, N being the number of elements in the sorted set, and M being the number of elements popped.
    • since: 7.0.0

    Parameters

    • Rest...args: [numkeys: string | number, ...keys: RedisKey[], min: "MIN", callback: Callback<unknown>]

    Returns Promise<unknown>

  • Parameters

    • Rest...args: [numkeys: string | number, keys: RedisKey[], min: "MIN", callback: Callback<unknown>]

    Returns Promise<unknown>

  • Parameters

    • Rest...args: [numkeys: string | number, ...keys: RedisKey[], min: "MIN"]

    Returns Promise<unknown>

  • Parameters

    • Rest...args: [numkeys: string | number, keys: RedisKey[], min: "MIN"]

    Returns Promise<unknown>

  • Parameters

    • Rest...args: [numkeys: string | number, ...keys: RedisKey[], min: "MIN", countToken: "COUNT", count: string | number, callback: Callback<unknown>]

    Returns Promise<unknown>

  • Parameters

    • Rest...args: [numkeys: string | number, keys: RedisKey[], min: "MIN", countToken: "COUNT", count: string | number, callback: Callback<unknown>]

    Returns Promise<unknown>

  • Parameters

    • Rest...args: [numkeys: string | number, ...keys: RedisKey[], min: "MIN", countToken: "COUNT", count: string | number]

    Returns Promise<unknown>

  • Parameters

    • Rest...args: [numkeys: string | number, keys: RedisKey[], min: "MIN", countToken: "COUNT", count: string | number]

    Returns Promise<unknown>

  • Parameters

    • Rest...args: [numkeys: string | number, ...keys: RedisKey[], max: "MAX", callback: Callback<unknown>]

    Returns Promise<unknown>

  • Parameters

    • Rest...args: [numkeys: string | number, keys: RedisKey[], max: "MAX", callback: Callback<unknown>]

    Returns Promise<unknown>

  • Parameters

    • Rest...args: [numkeys: string | number, ...keys: RedisKey[], max: "MAX"]

    Returns Promise<unknown>

  • Parameters

    • Rest...args: [numkeys: string | number, keys: RedisKey[], max: "MAX"]

    Returns Promise<unknown>

  • Parameters

    • Rest...args: [numkeys: string | number, ...keys: RedisKey[], max: "MAX", countToken: "COUNT", count: string | number, callback: Callback<unknown>]

    Returns Promise<unknown>

  • Parameters

    • Rest...args: [numkeys: string | number, keys: RedisKey[], max: "MAX", countToken: "COUNT", count: string | number, callback: Callback<unknown>]

    Returns Promise<unknown>

  • Parameters

    • Rest...args: [numkeys: string | number, ...keys: RedisKey[], max: "MAX", countToken: "COUNT", count: string | number]

    Returns Promise<unknown>

  • Parameters

    • Rest...args: [numkeys: string | number, keys: RedisKey[], max: "MAX", countToken: "COUNT", count: string | number]

    Returns Promise<unknown>

  • Get the score associated with the given members in a sorted set

    • group: sorted-set
    • complexity: O(N) where N is the number of members being requested.
    • since: 6.2.0

    Parameters

    • Rest...args: [key: RedisKey, ...members: (string | number | Buffer)[], callback: Callback<(null | string)[]>]

    Returns Promise<(null | string)[]>

  • Parameters

    • Rest...args: [key: RedisKey, members: (string | number | Buffer)[], callback: Callback<(null | string)[]>]

    Returns Promise<(null | string)[]>

  • Parameters

    • Rest...args: [key: RedisKey, ...members: (string | number | Buffer)[]]

    Returns Promise<(null | string)[]>

  • Parameters

    • Rest...args: [key: RedisKey, members: (string | number | Buffer)[]]

    Returns Promise<(null | string)[]>

  • Parameters

    • Rest...args: [key: RedisKey, ...members: (string | number | Buffer)[], callback: Callback<(null | Buffer)[]>]

    Returns Promise<(null | Buffer)[]>

  • Parameters

    • Rest...args: [key: RedisKey, members: (string | number | Buffer)[], callback: Callback<(null | Buffer)[]>]

    Returns Promise<(null | Buffer)[]>

  • Parameters

    • Rest...args: [key: RedisKey, ...members: (string | number | Buffer)[]]

    Returns Promise<(null | Buffer)[]>

  • Parameters

    • Rest...args: [key: RedisKey, members: (string | number | Buffer)[]]

    Returns Promise<(null | Buffer)[]>

  • Remove and return members with the highest scores in a sorted set

    • group: sorted-set
    • complexity: O(log(N)*M) with N being the number of elements in the sorted set, and M being the number of elements popped.
    • since: 5.0.0

    Parameters

    • key: RedisKey
    • Optionalcallback: Callback<string[]>

    Returns Promise<string[]>

  • Parameters

    • key: RedisKey
    • count: string | number
    • Optionalcallback: Callback<string[]>

    Returns Promise<string[]>

  • Parameters

    • key: RedisKey
    • Optionalcallback: Callback<Buffer[]>

    Returns Promise<Buffer[]>

  • Parameters

    • key: RedisKey
    • count: string | number
    • Optionalcallback: Callback<Buffer[]>

    Returns Promise<Buffer[]>

  • Remove and return members with the lowest scores in a sorted set

    • group: sorted-set
    • complexity: O(log(N)*M) with N being the number of elements in the sorted set, and M being the number of elements popped.
    • since: 5.0.0

    Parameters

    • key: RedisKey
    • Optionalcallback: Callback<string[]>

    Returns Promise<string[]>

  • Parameters

    • key: RedisKey
    • count: string | number
    • Optionalcallback: Callback<string[]>

    Returns Promise<string[]>

  • Parameters

    • key: RedisKey
    • Optionalcallback: Callback<Buffer[]>

    Returns Promise<Buffer[]>

  • Parameters

    • key: RedisKey
    • count: string | number
    • Optionalcallback: Callback<Buffer[]>

    Returns Promise<Buffer[]>

  • Get one or multiple random elements from a sorted set

    • group: sorted-set
    • complexity: O(N) where N is the number of elements returned
    • since: 6.2.0

    Parameters

    • key: RedisKey
    • Optionalcallback: Callback<null | string>

    Returns Promise<null | string>

  • Parameters

    • key: RedisKey
    • count: string | number
    • Optionalcallback: Callback<string[]>

    Returns Promise<string[]>

  • Parameters

    • key: RedisKey
    • count: string | number
    • withscores: "WITHSCORES"
    • Optionalcallback: Callback<string[]>

    Returns Promise<string[]>

  • Parameters

    • key: RedisKey
    • Optionalcallback: Callback<null | Buffer>

    Returns Promise<null | Buffer>

  • Parameters

    • key: RedisKey
    • count: string | number
    • Optionalcallback: Callback<Buffer[]>

    Returns Promise<Buffer[]>

  • Parameters

    • key: RedisKey
    • count: string | number
    • withscores: "WITHSCORES"
    • Optionalcallback: Callback<Buffer[]>

    Returns Promise<Buffer[]>

  • Return a range of members in a sorted set

    • group: sorted-set
    • complexity: O(log(N)+M) with N being the number of elements in the sorted set and M the number of elements returned.
    • since: 1.2.0

    Parameters

    • key: RedisKey
    • min: string | number | Buffer
    • max: string | number | Buffer
    • Optionalcallback: Callback<string[]>

    Returns Promise<string[]>

  • Parameters

    • key: RedisKey
    • min: string | number | Buffer
    • max: string | number | Buffer
    • withscores: "WITHSCORES"
    • Optionalcallback: Callback<string[]>

    Returns Promise<string[]>

  • Parameters

    • key: RedisKey
    • min: string | number | Buffer
    • max: string | number | Buffer
    • offsetCountToken: "LIMIT"
    • offset: string | number
    • count: string | number
    • Optionalcallback: Callback<string[]>

    Returns Promise<string[]>

  • Parameters

    • key: RedisKey
    • min: string | number | Buffer
    • max: string | number | Buffer
    • offsetCountToken: "LIMIT"
    • offset: string | number
    • count: string | number
    • withscores: "WITHSCORES"
    • Optionalcallback: Callback<string[]>

    Returns Promise<string[]>

  • Parameters

    • key: RedisKey
    • min: string | number | Buffer
    • max: string | number | Buffer
    • rev: "REV"
    • Optionalcallback: Callback<string[]>

    Returns Promise<string[]>

  • Parameters

    • key: RedisKey
    • min: string | number | Buffer
    • max: string | number | Buffer
    • rev: "REV"
    • withscores: "WITHSCORES"
    • Optionalcallback: Callback<string[]>

    Returns Promise<string[]>

  • Parameters

    • key: RedisKey
    • min: string | number | Buffer
    • max: string | number | Buffer
    • rev: "REV"
    • offsetCountToken: "LIMIT"
    • offset: string | number
    • count: string | number
    • Optionalcallback: Callback<string[]>

    Returns Promise<string[]>

  • Parameters

    • key: RedisKey
    • min: string | number | Buffer
    • max: string | number | Buffer
    • rev: "REV"
    • offsetCountToken: "LIMIT"
    • offset: string | number
    • count: string | number
    • withscores: "WITHSCORES"
    • Optionalcallback: Callback<string[]>

    Returns Promise<string[]>

  • Parameters

    • key: RedisKey
    • min: string | number | Buffer
    • max: string | number | Buffer
    • byscore: "BYSCORE"
    • Optionalcallback: Callback<string[]>

    Returns Promise<string[]>

  • Parameters

    • key: RedisKey
    • min: string | number | Buffer
    • max: string | number | Buffer
    • byscore: "BYSCORE"
    • withscores: "WITHSCORES"
    • Optionalcallback: Callback<string[]>

    Returns Promise<string[]>

  • Parameters

    • key: RedisKey
    • min: string | number | Buffer
    • max: string | number | Buffer
    • byscore: "BYSCORE"
    • offsetCountToken: "LIMIT"
    • offset: string | number
    • count: string | number
    • Optionalcallback: Callback<string[]>

    Returns Promise<string[]>

  • Parameters

    • key: RedisKey
    • min: string | number | Buffer
    • max: string | number | Buffer
    • byscore: "BYSCORE"
    • offsetCountToken: "LIMIT"
    • offset: string | number
    • count: string | number
    • withscores: "WITHSCORES"
    • Optionalcallback: Callback<string[]>

    Returns Promise<string[]>

  • Parameters

    • key: RedisKey
    • min: string | number | Buffer
    • max: string | number | Buffer
    • byscore: "BYSCORE"
    • rev: "REV"
    • Optionalcallback: Callback<string[]>

    Returns Promise<string[]>

  • Parameters

    • key: RedisKey
    • min: string | number | Buffer
    • max: string | number | Buffer
    • byscore: "BYSCORE"
    • rev: "REV"
    • withscores: "WITHSCORES"
    • Optionalcallback: Callback<string[]>

    Returns Promise<string[]>

  • Parameters

    • key: RedisKey
    • min: string | number | Buffer
    • max: string | number | Buffer
    • byscore: "BYSCORE"
    • rev: "REV"
    • offsetCountToken: "LIMIT"
    • offset: string | number
    • count: string | number
    • Optionalcallback: Callback<string[]>

    Returns Promise<string[]>

  • Parameters

    • key: RedisKey
    • min: string | number | Buffer
    • max: string | number | Buffer
    • byscore: "BYSCORE"
    • rev: "REV"
    • offsetCountToken: "LIMIT"
    • offset: string | number
    • count: string | number
    • withscores: "WITHSCORES"
    • Optionalcallback: Callback<string[]>

    Returns Promise<string[]>

  • Parameters

    • key: RedisKey
    • min: string | number | Buffer
    • max: string | number | Buffer
    • bylex: "BYLEX"
    • Optionalcallback: Callback<string[]>

    Returns Promise<string[]>

  • Parameters

    • key: RedisKey
    • min: string | number | Buffer
    • max: string | number | Buffer
    • bylex: "BYLEX"
    • withscores: "WITHSCORES"
    • Optionalcallback: Callback<string[]>

    Returns Promise<string[]>

  • Parameters

    • key: RedisKey
    • min: string | number | Buffer
    • max: string | number | Buffer
    • bylex: "BYLEX"
    • offsetCountToken: "LIMIT"
    • offset: string | number
    • count: string | number
    • Optionalcallback: Callback<string[]>

    Returns Promise<string[]>

  • Parameters

    • key: RedisKey
    • min: string | number | Buffer
    • max: string | number | Buffer
    • bylex: "BYLEX"
    • offsetCountToken: "LIMIT"
    • offset: string | number
    • count: string | number
    • withscores: "WITHSCORES"
    • Optionalcallback: Callback<string[]>

    Returns Promise<string[]>

  • Parameters

    • key: RedisKey
    • min: string | number | Buffer
    • max: string | number | Buffer
    • bylex: "BYLEX"
    • rev: "REV"
    • Optionalcallback: Callback<string[]>

    Returns Promise<string[]>

  • Parameters

    • key: RedisKey
    • min: string | number | Buffer
    • max: string | number | Buffer
    • bylex: "BYLEX"
    • rev: "REV"
    • withscores: "WITHSCORES"
    • Optionalcallback: Callback<string[]>

    Returns Promise<string[]>

  • Parameters

    • key: RedisKey
    • min: string | number | Buffer
    • max: string | number | Buffer
    • bylex: "BYLEX"
    • rev: "REV"
    • offsetCountToken: "LIMIT"
    • offset: string | number
    • count: string | number
    • Optionalcallback: Callback<string[]>

    Returns Promise<string[]>

  • Parameters

    • key: RedisKey
    • min: string | number | Buffer
    • max: string | number | Buffer
    • bylex: "BYLEX"
    • rev: "REV"
    • offsetCountToken: "LIMIT"
    • offset: string | number
    • count: string | number
    • withscores: "WITHSCORES"
    • Optionalcallback: Callback<string[]>

    Returns Promise<string[]>

  • Parameters

    • key: RedisKey
    • min: string | number | Buffer
    • max: string | number | Buffer
    • Optionalcallback: Callback<Buffer[]>

    Returns Promise<Buffer[]>

  • Parameters

    • key: RedisKey
    • min: string | number | Buffer
    • max: string | number | Buffer
    • withscores: "WITHSCORES"
    • Optionalcallback: Callback<Buffer[]>

    Returns Promise<Buffer[]>

  • Parameters

    • key: RedisKey
    • min: string | number | Buffer
    • max: string | number | Buffer
    • offsetCountToken: "LIMIT"
    • offset: string | number
    • count: string | number
    • Optionalcallback: Callback<Buffer[]>

    Returns Promise<Buffer[]>

  • Parameters

    • key: RedisKey
    • min: string | number | Buffer
    • max: string | number | Buffer
    • offsetCountToken: "LIMIT"
    • offset: string | number
    • count: string | number
    • withscores: "WITHSCORES"
    • Optionalcallback: Callback<Buffer[]>

    Returns Promise<Buffer[]>

  • Parameters

    • key: RedisKey
    • min: string | number | Buffer
    • max: string | number | Buffer
    • rev: "REV"
    • Optionalcallback: Callback<Buffer[]>

    Returns Promise<Buffer[]>

  • Parameters

    • key: RedisKey
    • min: string | number | Buffer
    • max: string | number | Buffer
    • rev: "REV"
    • withscores: "WITHSCORES"
    • Optionalcallback: Callback<Buffer[]>

    Returns Promise<Buffer[]>

  • Parameters

    • key: RedisKey
    • min: string | number | Buffer
    • max: string | number | Buffer
    • rev: "REV"
    • offsetCountToken: "LIMIT"
    • offset: string | number
    • count: string | number
    • Optionalcallback: Callback<Buffer[]>

    Returns Promise<Buffer[]>

  • Parameters

    • key: RedisKey
    • min: string | number | Buffer
    • max: string | number | Buffer
    • rev: "REV"
    • offsetCountToken: "LIMIT"
    • offset: string | number
    • count: string | number
    • withscores: "WITHSCORES"
    • Optionalcallback: Callback<Buffer[]>

    Returns Promise<Buffer[]>

  • Parameters

    • key: RedisKey
    • min: string | number | Buffer
    • max: string | number | Buffer
    • byscore: "BYSCORE"
    • Optionalcallback: Callback<Buffer[]>

    Returns Promise<Buffer[]>

  • Parameters

    • key: RedisKey
    • min: string | number | Buffer
    • max: string | number | Buffer
    • byscore: "BYSCORE"
    • withscores: "WITHSCORES"
    • Optionalcallback: Callback<Buffer[]>

    Returns Promise<Buffer[]>

  • Parameters

    • key: RedisKey
    • min: string | number | Buffer
    • max: string | number | Buffer
    • byscore: "BYSCORE"
    • offsetCountToken: "LIMIT"
    • offset: string | number
    • count: string | number
    • Optionalcallback: Callback<Buffer[]>

    Returns Promise<Buffer[]>

  • Parameters

    • key: RedisKey
    • min: string | number | Buffer
    • max: string | number | Buffer
    • byscore: "BYSCORE"
    • offsetCountToken: "LIMIT"
    • offset: string | number
    • count: string | number
    • withscores: "WITHSCORES"
    • Optionalcallback: Callback<Buffer[]>

    Returns Promise<Buffer[]>

  • Parameters

    • key: RedisKey
    • min: string | number | Buffer
    • max: string | number | Buffer
    • byscore: "BYSCORE"
    • rev: "REV"
    • Optionalcallback: Callback<Buffer[]>

    Returns Promise<Buffer[]>

  • Parameters

    • key: RedisKey
    • min: string | number | Buffer
    • max: string | number | Buffer
    • byscore: "BYSCORE"
    • rev: "REV"
    • withscores: "WITHSCORES"
    • Optionalcallback: Callback<Buffer[]>

    Returns Promise<Buffer[]>

  • Parameters

    • key: RedisKey
    • min: string | number | Buffer
    • max: string | number | Buffer
    • byscore: "BYSCORE"
    • rev: "REV"
    • offsetCountToken: "LIMIT"
    • offset: string | number
    • count: string | number
    • Optionalcallback: Callback<Buffer[]>

    Returns Promise<Buffer[]>

  • Parameters

    • key: RedisKey
    • min: string | number | Buffer
    • max: string | number | Buffer
    • byscore: "BYSCORE"
    • rev: "REV"
    • offsetCountToken: "LIMIT"
    • offset: string | number
    • count: string | number
    • withscores: "WITHSCORES"
    • Optionalcallback: Callback<Buffer[]>

    Returns Promise<Buffer[]>

  • Parameters

    • key: RedisKey
    • min: string | number | Buffer
    • max: string | number | Buffer
    • bylex: "BYLEX"
    • Optionalcallback: Callback<Buffer[]>

    Returns Promise<Buffer[]>

  • Parameters

    • key: RedisKey
    • min: string | number | Buffer
    • max: string | number | Buffer
    • bylex: "BYLEX"
    • withscores: "WITHSCORES"
    • Optionalcallback: Callback<Buffer[]>

    Returns Promise<Buffer[]>

  • Parameters

    • key: RedisKey
    • min: string | number | Buffer
    • max: string | number | Buffer
    • bylex: "BYLEX"
    • offsetCountToken: "LIMIT"
    • offset: string | number
    • count: string | number
    • Optionalcallback: Callback<Buffer[]>

    Returns Promise<Buffer[]>

  • Parameters

    • key: RedisKey
    • min: string | number | Buffer
    • max: string | number | Buffer
    • bylex: "BYLEX"
    • offsetCountToken: "LIMIT"
    • offset: string | number
    • count: string | number
    • withscores: "WITHSCORES"
    • Optionalcallback: Callback<Buffer[]>

    Returns Promise<Buffer[]>

  • Parameters

    • key: RedisKey
    • min: string | number | Buffer
    • max: string | number | Buffer
    • bylex: "BYLEX"
    • rev: "REV"
    • Optionalcallback: Callback<Buffer[]>

    Returns Promise<Buffer[]>

  • Parameters

    • key: RedisKey
    • min: string | number | Buffer
    • max: string | number | Buffer
    • bylex: "BYLEX"
    • rev: "REV"
    • withscores: "WITHSCORES"
    • Optionalcallback: Callback<Buffer[]>

    Returns Promise<Buffer[]>

  • Parameters

    • key: RedisKey
    • min: string | number | Buffer
    • max: string | number | Buffer
    • bylex: "BYLEX"
    • rev: "REV"
    • offsetCountToken: "LIMIT"
    • offset: string | number
    • count: string | number
    • Optionalcallback: Callback<Buffer[]>

    Returns Promise<Buffer[]>

  • Parameters

    • key: RedisKey
    • min: string | number | Buffer
    • max: string | number | Buffer
    • bylex: "BYLEX"
    • rev: "REV"
    • offsetCountToken: "LIMIT"
    • offset: string | number
    • count: string | number
    • withscores: "WITHSCORES"
    • Optionalcallback: Callback<Buffer[]>

    Returns Promise<Buffer[]>

  • Return a range of members in a sorted set, by lexicographical range

    • group: sorted-set
    • complexity: O(log(N)+M) with N being the number of elements in the sorted set and M the number of elements being returned. If M is constant (e.g. always asking for the first 10 elements with LIMIT), you can consider it O(log(N)).
    • since: 2.8.9

    Parameters

    • key: RedisKey
    • min: string | number | Buffer
    • max: string | number | Buffer
    • Optionalcallback: Callback<string[]>

    Returns Promise<string[]>

  • Parameters

    • key: RedisKey
    • min: string | number | Buffer
    • max: string | number | Buffer
    • offsetCountToken: "LIMIT"
    • offset: string | number
    • count: string | number
    • Optionalcallback: Callback<string[]>

    Returns Promise<string[]>

  • Parameters

    • key: RedisKey
    • min: string | number | Buffer
    • max: string | number | Buffer
    • Optionalcallback: Callback<Buffer[]>

    Returns Promise<Buffer[]>

  • Parameters

    • key: RedisKey
    • min: string | number | Buffer
    • max: string | number | Buffer
    • offsetCountToken: "LIMIT"
    • offset: string | number
    • count: string | number
    • Optionalcallback: Callback<Buffer[]>

    Returns Promise<Buffer[]>

  • Return a range of members in a sorted set, by score

    • group: sorted-set
    • complexity: O(log(N)+M) with N being the number of elements in the sorted set and M the number of elements being returned. If M is constant (e.g. always asking for the first 10 elements with LIMIT), you can consider it O(log(N)).
    • since: 1.0.5

    Parameters

    • key: RedisKey
    • min: string | number
    • max: string | number
    • Optionalcallback: Callback<string[]>

    Returns Promise<string[]>

  • Parameters

    • key: RedisKey
    • min: string | number
    • max: string | number
    • offsetCountToken: "LIMIT"
    • offset: string | number
    • count: string | number
    • Optionalcallback: Callback<string[]>

    Returns Promise<string[]>

  • Parameters

    • key: RedisKey
    • min: string | number
    • max: string | number
    • withscores: "WITHSCORES"
    • Optionalcallback: Callback<string[]>

    Returns Promise<string[]>

  • Parameters

    • key: RedisKey
    • min: string | number
    • max: string | number
    • withscores: "WITHSCORES"
    • offsetCountToken: "LIMIT"
    • offset: string | number
    • count: string | number
    • Optionalcallback: Callback<string[]>

    Returns Promise<string[]>

  • Parameters

    • key: RedisKey
    • min: string | number
    • max: string | number
    • Optionalcallback: Callback<Buffer[]>

    Returns Promise<Buffer[]>

  • Parameters

    • key: RedisKey
    • min: string | number
    • max: string | number
    • offsetCountToken: "LIMIT"
    • offset: string | number
    • count: string | number
    • Optionalcallback: Callback<Buffer[]>

    Returns Promise<Buffer[]>

  • Parameters

    • key: RedisKey
    • min: string | number
    • max: string | number
    • withscores: "WITHSCORES"
    • Optionalcallback: Callback<Buffer[]>

    Returns Promise<Buffer[]>

  • Parameters

    • key: RedisKey
    • min: string | number
    • max: string | number
    • withscores: "WITHSCORES"
    • offsetCountToken: "LIMIT"
    • offset: string | number
    • count: string | number
    • Optionalcallback: Callback<Buffer[]>

    Returns Promise<Buffer[]>

  • Store a range of members from sorted set into another key

    • group: sorted-set
    • complexity: O(log(N)+M) with N being the number of elements in the sorted set and M the number of elements stored into the destination key.
    • since: 6.2.0

    Parameters

    • dst: RedisKey
    • src: RedisKey
    • min: string | number | Buffer
    • max: string | number | Buffer
    • Optionalcallback: Callback<number>

    Returns Promise<number>

  • Parameters

    • dst: RedisKey
    • src: RedisKey
    • min: string | number | Buffer
    • max: string | number | Buffer
    • offsetCountToken: "LIMIT"
    • offset: string | number
    • count: string | number
    • Optionalcallback: Callback<number>

    Returns Promise<number>

  • Parameters

    • dst: RedisKey
    • src: RedisKey
    • min: string | number | Buffer
    • max: string | number | Buffer
    • rev: "REV"
    • Optionalcallback: Callback<number>

    Returns Promise<number>

  • Parameters

    • dst: RedisKey
    • src: RedisKey
    • min: string | number | Buffer
    • max: string | number | Buffer
    • rev: "REV"
    • offsetCountToken: "LIMIT"
    • offset: string | number
    • count: string | number
    • Optionalcallback: Callback<number>

    Returns Promise<number>

  • Parameters

    • dst: RedisKey
    • src: RedisKey
    • min: string | number | Buffer
    • max: string | number | Buffer
    • byscore: "BYSCORE"
    • Optionalcallback: Callback<number>

    Returns Promise<number>

  • Parameters

    • dst: RedisKey
    • src: RedisKey
    • min: string | number | Buffer
    • max: string | number | Buffer
    • byscore: "BYSCORE"
    • offsetCountToken: "LIMIT"
    • offset: string | number
    • count: string | number
    • Optionalcallback: Callback<number>

    Returns Promise<number>

  • Parameters

    • dst: RedisKey
    • src: RedisKey
    • min: string | number | Buffer
    • max: string | number | Buffer
    • byscore: "BYSCORE"
    • rev: "REV"
    • Optionalcallback: Callback<number>

    Returns Promise<number>

  • Parameters

    • dst: RedisKey
    • src: RedisKey
    • min: string | number | Buffer
    • max: string | number | Buffer
    • byscore: "BYSCORE"
    • rev: "REV"
    • offsetCountToken: "LIMIT"
    • offset: string | number
    • count: string | number
    • Optionalcallback: Callback<number>

    Returns Promise<number>

  • Parameters

    • dst: RedisKey
    • src: RedisKey
    • min: string | number | Buffer
    • max: string | number | Buffer
    • bylex: "BYLEX"
    • Optionalcallback: Callback<number>

    Returns Promise<number>

  • Parameters

    • dst: RedisKey
    • src: RedisKey
    • min: string | number | Buffer
    • max: string | number | Buffer
    • bylex: "BYLEX"
    • offsetCountToken: "LIMIT"
    • offset: string | number
    • count: string | number
    • Optionalcallback: Callback<number>

    Returns Promise<number>

  • Parameters

    • dst: RedisKey
    • src: RedisKey
    • min: string | number | Buffer
    • max: string | number | Buffer
    • bylex: "BYLEX"
    • rev: "REV"
    • Optionalcallback: Callback<number>

    Returns Promise<number>

  • Parameters

    • dst: RedisKey
    • src: RedisKey
    • min: string | number | Buffer
    • max: string | number | Buffer
    • bylex: "BYLEX"
    • rev: "REV"
    • offsetCountToken: "LIMIT"
    • offset: string | number
    • count: string | number
    • Optionalcallback: Callback<number>

    Returns Promise<number>

  • Determine the index of a member in a sorted set

    • group: sorted-set
    • complexity: O(log(N))
    • since: 2.0.0

    Parameters

    • key: RedisKey
    • member: string | number | Buffer
    • Optionalcallback: Callback<null | number>

    Returns Promise<null | number>

  • Remove one or more members from a sorted set

    • group: sorted-set
    • complexity: O(M*log(N)) with N being the number of elements in the sorted set and M the number of elements to be removed.
    • since: 1.2.0

    Parameters

    • Rest...args: [key: RedisKey, ...members: (string | number | Buffer)[], callback: Callback<number>]

    Returns Promise<number>

  • Parameters

    • Rest...args: [key: RedisKey, members: (string | number | Buffer)[], callback: Callback<number>]

    Returns Promise<number>

  • Parameters

    • Rest...args: [key: RedisKey, ...members: (string | number | Buffer)[]]

    Returns Promise<number>

  • Parameters

    • Rest...args: [key: RedisKey, members: (string | number | Buffer)[]]

    Returns Promise<number>

  • Remove all members in a sorted set between the given lexicographical range

    • group: sorted-set
    • complexity: O(log(N)+M) with N being the number of elements in the sorted set and M the number of elements removed by the operation.
    • since: 2.8.9

    Parameters

    • key: RedisKey
    • min: string | number | Buffer
    • max: string | number | Buffer
    • Optionalcallback: Callback<number>

    Returns Promise<number>

  • Remove all members in a sorted set within the given indexes

    • group: sorted-set
    • complexity: O(log(N)+M) with N being the number of elements in the sorted set and M the number of elements removed by the operation.
    • since: 2.0.0

    Parameters

    • key: RedisKey
    • start: string | number
    • stop: string | number
    • Optionalcallback: Callback<number>

    Returns Promise<number>

  • Remove all members in a sorted set within the given scores

    • group: sorted-set
    • complexity: O(log(N)+M) with N being the number of elements in the sorted set and M the number of elements removed by the operation.
    • since: 1.2.0

    Parameters

    • key: RedisKey
    • min: string | number
    • max: string | number
    • Optionalcallback: Callback<number>

    Returns Promise<number>

  • Return a range of members in a sorted set, by index, with scores ordered from high to low

    • group: sorted-set
    • complexity: O(log(N)+M) with N being the number of elements in the sorted set and M the number of elements returned.
    • since: 1.2.0

    Parameters

    • key: RedisKey
    • start: string | number
    • stop: string | number
    • Optionalcallback: Callback<string[]>

    Returns Promise<string[]>

  • Parameters

    • key: RedisKey
    • start: string | number
    • stop: string | number
    • withscores: "WITHSCORES"
    • Optionalcallback: Callback<string[]>

    Returns Promise<string[]>

  • Parameters

    • key: RedisKey
    • start: string | number
    • stop: string | number
    • Optionalcallback: Callback<Buffer[]>

    Returns Promise<Buffer[]>

  • Parameters

    • key: RedisKey
    • start: string | number
    • stop: string | number
    • withscores: "WITHSCORES"
    • Optionalcallback: Callback<Buffer[]>

    Returns Promise<Buffer[]>

  • Return a range of members in a sorted set, by lexicographical range, ordered from higher to lower strings.

    • group: sorted-set
    • complexity: O(log(N)+M) with N being the number of elements in the sorted set and M the number of elements being returned. If M is constant (e.g. always asking for the first 10 elements with LIMIT), you can consider it O(log(N)).
    • since: 2.8.9

    Parameters

    • key: RedisKey
    • max: string | number | Buffer
    • min: string | number | Buffer
    • Optionalcallback: Callback<string[]>

    Returns Promise<string[]>

  • Parameters

    • key: RedisKey
    • max: string | number | Buffer
    • min: string | number | Buffer
    • offsetCountToken: "LIMIT"
    • offset: string | number
    • count: string | number
    • Optionalcallback: Callback<string[]>

    Returns Promise<string[]>

  • Parameters

    • key: RedisKey
    • max: string | number | Buffer
    • min: string | number | Buffer
    • Optionalcallback: Callback<Buffer[]>

    Returns Promise<Buffer[]>

  • Parameters

    • key: RedisKey
    • max: string | number | Buffer
    • min: string | number | Buffer
    • offsetCountToken: "LIMIT"
    • offset: string | number
    • count: string | number
    • Optionalcallback: Callback<Buffer[]>

    Returns Promise<Buffer[]>

  • Return a range of members in a sorted set, by score, with scores ordered from high to low

    • group: sorted-set
    • complexity: O(log(N)+M) with N being the number of elements in the sorted set and M the number of elements being returned. If M is constant (e.g. always asking for the first 10 elements with LIMIT), you can consider it O(log(N)).
    • since: 2.2.0

    Parameters

    • key: RedisKey
    • max: string | number
    • min: string | number
    • Optionalcallback: Callback<string[]>

    Returns Promise<string[]>

  • Parameters

    • key: RedisKey
    • max: string | number
    • min: string | number
    • offsetCountToken: "LIMIT"
    • offset: string | number
    • count: string | number
    • Optionalcallback: Callback<string[]>

    Returns Promise<string[]>

  • Parameters

    • key: RedisKey
    • max: string | number
    • min: string | number
    • withscores: "WITHSCORES"
    • Optionalcallback: Callback<string[]>

    Returns Promise<string[]>

  • Parameters

    • key: RedisKey
    • max: string | number
    • min: string | number
    • withscores: "WITHSCORES"
    • offsetCountToken: "LIMIT"
    • offset: string | number
    • count: string | number
    • Optionalcallback: Callback<string[]>

    Returns Promise<string[]>

  • Parameters

    • key: RedisKey
    • max: string | number
    • min: string | number
    • Optionalcallback: Callback<Buffer[]>

    Returns Promise<Buffer[]>

  • Parameters

    • key: RedisKey
    • max: string | number
    • min: string | number
    • offsetCountToken: "LIMIT"
    • offset: string | number
    • count: string | number
    • Optionalcallback: Callback<Buffer[]>

    Returns Promise<Buffer[]>

  • Parameters

    • key: RedisKey
    • max: string | number
    • min: string | number
    • withscores: "WITHSCORES"
    • Optionalcallback: Callback<Buffer[]>

    Returns Promise<Buffer[]>

  • Parameters

    • key: RedisKey
    • max: string | number
    • min: string | number
    • withscores: "WITHSCORES"
    • offsetCountToken: "LIMIT"
    • offset: string | number
    • count: string | number
    • Optionalcallback: Callback<Buffer[]>

    Returns Promise<Buffer[]>

  • Determine the index of a member in a sorted set, with scores ordered from high to low

    • group: sorted-set
    • complexity: O(log(N))
    • since: 2.0.0

    Parameters

    • key: RedisKey
    • member: string | number | Buffer
    • Optionalcallback: Callback<null | number>

    Returns Promise<null | number>

  • Incrementally iterate sorted sets elements and associated scores

    • group: sorted-set
    • complexity: O(1) for every call. O(N) for a complete iteration, including enough command calls for the cursor to return back to 0. N is the number of elements inside the collection..
    • since: 2.8.0

    Parameters

    • key: RedisKey
    • cursor: string | number
    • Optionalcallback: Callback<[cursor: string, elements: string[]]>

    Returns Promise<[cursor: string, elements: string[]]>

  • Parameters

    • key: RedisKey
    • cursor: string | number
    • countToken: "COUNT"
    • count: string | number
    • Optionalcallback: Callback<[cursor: string, elements: string[]]>

    Returns Promise<[cursor: string, elements: string[]]>

  • Parameters

    • key: RedisKey
    • cursor: string | number
    • patternToken: "MATCH"
    • pattern: string
    • Optionalcallback: Callback<[cursor: string, elements: string[]]>

    Returns Promise<[cursor: string, elements: string[]]>

  • Parameters

    • key: RedisKey
    • cursor: string | number
    • patternToken: "MATCH"
    • pattern: string
    • countToken: "COUNT"
    • count: string | number
    • Optionalcallback: Callback<[cursor: string, elements: string[]]>

    Returns Promise<[cursor: string, elements: string[]]>

  • Parameters

    • key: RedisKey
    • cursor: string | number
    • Optionalcallback: Callback<[cursor: Buffer, elements: Buffer[]]>

    Returns Promise<[cursor: Buffer, elements: Buffer[]]>

  • Parameters

    • key: RedisKey
    • cursor: string | number
    • countToken: "COUNT"
    • count: string | number
    • Optionalcallback: Callback<[cursor: Buffer, elements: Buffer[]]>

    Returns Promise<[cursor: Buffer, elements: Buffer[]]>

  • Parameters

    • key: RedisKey
    • cursor: string | number
    • patternToken: "MATCH"
    • pattern: string
    • Optionalcallback: Callback<[cursor: Buffer, elements: Buffer[]]>

    Returns Promise<[cursor: Buffer, elements: Buffer[]]>

  • Parameters

    • key: RedisKey
    • cursor: string | number
    • patternToken: "MATCH"
    • pattern: string
    • countToken: "COUNT"
    • count: string | number
    • Optionalcallback: Callback<[cursor: Buffer, elements: Buffer[]]>

    Returns Promise<[cursor: Buffer, elements: Buffer[]]>

  • Parameters

    • key: string
    • Optionaloptions: ScanStreamOptions

    Returns ScanStream

  • Parameters

    • key: string
    • Optionaloptions: ScanStreamOptions

    Returns ScanStream

  • Get the score associated with the given member in a sorted set

    • group: sorted-set
    • complexity: O(1)
    • since: 1.2.0

    Parameters

    • key: RedisKey
    • member: string | number | Buffer
    • Optionalcallback: Callback<null | string>

    Returns Promise<null | string>

  • Parameters

    • key: RedisKey
    • member: string | number | Buffer
    • Optionalcallback: Callback<null | Buffer>

    Returns Promise<null | Buffer>

  • Add multiple sorted sets

    • group: sorted-set
    • complexity: O(N)+O(M*log(M)) with N being the sum of the sizes of the input sorted sets, and M being the number of elements in the resulting sorted set.
    • since: 6.2.0

    Parameters

    • Rest...args: [numkeys: string | number, ...keys: RedisKey[], callback: Callback<string[]>]

    Returns Promise<string[]>

  • Parameters

    • Rest...args: [numkeys: string | number, keys: RedisKey[], callback: Callback<string[]>]

    Returns Promise<string[]>

  • Parameters

    • Rest...args: [numkeys: string | number, ...keys: RedisKey[]]

    Returns Promise<string[]>

  • Parameters

    • Rest...args: [numkeys: string | number, keys: RedisKey[]]

    Returns Promise<string[]>

  • Parameters

    • Rest...args: [numkeys: string | number, ...keys: RedisKey[], withscores: "WITHSCORES", callback: Callback<string[]>]

    Returns Promise<string[]>

  • Parameters

    • Rest...args: [numkeys: string | number, keys: RedisKey[], withscores: "WITHSCORES", callback: Callback<string[]>]

    Returns Promise<string[]>

  • Parameters

    • Rest...args: [numkeys: string | number, ...keys: RedisKey[], withscores: "WITHSCORES"]

    Returns Promise<string[]>

  • Parameters

    • Rest...args: [numkeys: string | number, keys: RedisKey[], withscores: "WITHSCORES"]

    Returns Promise<string[]>

  • Parameters

    • Rest...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<string[]>]

    Returns Promise<string[]>

  • Parameters

    • Rest...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<string[]>]

    Returns Promise<string[]>

  • Parameters

    • Rest...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM"]

    Returns Promise<string[]>

  • Parameters

    • Rest...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM"]

    Returns Promise<string[]>

  • Parameters

    • Rest...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES", callback: Callback<string[]>]

    Returns Promise<string[]>

  • Parameters

    • Rest...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES", callback: Callback<string[]>]

    Returns Promise<string[]>

  • Parameters

    • Rest...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES"]

    Returns Promise<string[]>

  • Parameters

    • Rest...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES"]

    Returns Promise<string[]>

  • Parameters

    • Rest...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", callback: Callback<string[]>]

    Returns Promise<string[]>

  • Parameters

    • Rest...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", callback: Callback<string[]>]

    Returns Promise<string[]>

  • Parameters

    • Rest...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN"]

    Returns Promise<string[]>

  • Parameters

    • Rest...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN"]

    Returns Promise<string[]>

  • Parameters

    • Rest...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES", callback: Callback<string[]>]

    Returns Promise<string[]>

  • Parameters

    • Rest...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES", callback: Callback<string[]>]

    Returns Promise<string[]>

  • Parameters

    • Rest...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES"]

    Returns Promise<string[]>

  • Parameters

    • Rest...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES"]

    Returns Promise<string[]>

  • Parameters

    • Rest...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", callback: Callback<string[]>]

    Returns Promise<string[]>

  • Parameters

    • Rest...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", callback: Callback<string[]>]

    Returns Promise<string[]>

  • Parameters

    • Rest...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX"]

    Returns Promise<string[]>

  • Parameters

    • Rest...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX"]

    Returns Promise<string[]>

  • Parameters

    • Rest...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES", callback: Callback<string[]>]

    Returns Promise<string[]>

  • Parameters

    • Rest...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES", callback: Callback<string[]>]

    Returns Promise<string[]>

  • Parameters

    • Rest...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES"]

    Returns Promise<string[]>

  • Parameters

    • Rest...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES"]

    Returns Promise<string[]>

  • Parameters

    • Rest...args: [numkeys: string | number, ...args: RedisValue[], callback: Callback<string[]>]

    Returns Promise<string[]>

  • Parameters

    • Rest...args: [numkeys: string | number, ...args: RedisValue[]]

    Returns Promise<string[]>

  • Parameters

    • Rest...args: [numkeys: string | number, ...args: RedisValue[], withscores: "WITHSCORES", callback: Callback<string[]>]

    Returns Promise<string[]>

  • Parameters

    • Rest...args: [numkeys: string | number, ...args: RedisValue[], withscores: "WITHSCORES"]

    Returns Promise<string[]>

  • Parameters

    • Rest...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<string[]>]

    Returns Promise<string[]>

  • Parameters

    • Rest...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM"]

    Returns Promise<string[]>

  • Parameters

    • Rest...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES", callback: Callback<string[]>]

    Returns Promise<string[]>

  • Parameters

    • Rest...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES"]

    Returns Promise<string[]>

  • Parameters

    • Rest...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN", callback: Callback<string[]>]

    Returns Promise<string[]>

  • Parameters

    • Rest...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN"]

    Returns Promise<string[]>

  • Parameters

    • Rest...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES", callback: Callback<string[]>]

    Returns Promise<string[]>

  • Parameters

    • Rest...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES"]

    Returns Promise<string[]>

  • Parameters

    • Rest...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX", callback: Callback<string[]>]

    Returns Promise<string[]>

  • Parameters

    • Rest...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX"]

    Returns Promise<string[]>

  • Parameters

    • Rest...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES", callback: Callback<string[]>]

    Returns Promise<string[]>

  • Parameters

    • Rest...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES"]

    Returns Promise<string[]>

  • Parameters

    • Rest...args: [numkeys: string | number, ...keys: RedisKey[], callback: Callback<Buffer[]>]

    Returns Promise<Buffer[]>

  • Parameters

    • Rest...args: [numkeys: string | number, keys: RedisKey[], callback: Callback<Buffer[]>]

    Returns Promise<Buffer[]>

  • Parameters

    • Rest...args: [numkeys: string | number, ...keys: RedisKey[]]

    Returns Promise<Buffer[]>

  • Parameters

    • Rest...args: [numkeys: string | number, keys: RedisKey[]]

    Returns Promise<Buffer[]>

  • Parameters

    • Rest...args: [numkeys: string | number, ...keys: RedisKey[], withscores: "WITHSCORES", callback: Callback<Buffer[]>]

    Returns Promise<Buffer[]>

  • Parameters

    • Rest...args: [numkeys: string | number, keys: RedisKey[], withscores: "WITHSCORES", callback: Callback<Buffer[]>]

    Returns Promise<Buffer[]>

  • Parameters

    • Rest...args: [numkeys: string | number, ...keys: RedisKey[], withscores: "WITHSCORES"]

    Returns Promise<Buffer[]>

  • Parameters

    • Rest...args: [numkeys: string | number, keys: RedisKey[], withscores: "WITHSCORES"]

    Returns Promise<Buffer[]>

  • Parameters

    • Rest...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<Buffer[]>]

    Returns Promise<Buffer[]>

  • Parameters

    • Rest...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<Buffer[]>]

    Returns Promise<Buffer[]>

  • Parameters

    • Rest...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM"]

    Returns Promise<Buffer[]>

  • Parameters

    • Rest...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM"]

    Returns Promise<Buffer[]>

  • Parameters

    • Rest...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES", callback: Callback<Buffer[]>]

    Returns Promise<Buffer[]>

  • Parameters

    • Rest...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES", callback: Callback<Buffer[]>]

    Returns Promise<Buffer[]>

  • Parameters

    • Rest...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES"]

    Returns Promise<Buffer[]>

  • Parameters

    • Rest...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES"]

    Returns Promise<Buffer[]>

  • Parameters

    • Rest...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", callback: Callback<Buffer[]>]

    Returns Promise<Buffer[]>

  • Parameters

    • Rest...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", callback: Callback<Buffer[]>]

    Returns Promise<Buffer[]>

  • Parameters

    • Rest...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN"]

    Returns Promise<Buffer[]>

  • Parameters

    • Rest...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN"]

    Returns Promise<Buffer[]>

  • Parameters

    • Rest...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES", callback: Callback<Buffer[]>]

    Returns Promise<Buffer[]>

  • Parameters

    • Rest...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES", callback: Callback<Buffer[]>]

    Returns Promise<Buffer[]>

  • Parameters

    • Rest...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES"]

    Returns Promise<Buffer[]>

  • Parameters

    • Rest...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES"]

    Returns Promise<Buffer[]>

  • Parameters

    • Rest...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", callback: Callback<Buffer[]>]

    Returns Promise<Buffer[]>

  • Parameters

    • Rest...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", callback: Callback<Buffer[]>]

    Returns Promise<Buffer[]>

  • Parameters

    • Rest...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX"]

    Returns Promise<Buffer[]>

  • Parameters

    • Rest...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX"]

    Returns Promise<Buffer[]>

  • Parameters

    • Rest...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES", callback: Callback<Buffer[]>]

    Returns Promise<Buffer[]>

  • Parameters

    • Rest...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES", callback: Callback<Buffer[]>]

    Returns Promise<Buffer[]>

  • Parameters

    • Rest...args: [numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES"]

    Returns Promise<Buffer[]>

  • Parameters

    • Rest...args: [numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES"]

    Returns Promise<Buffer[]>

  • Parameters

    • Rest...args: [numkeys: string | number, ...args: RedisValue[], callback: Callback<Buffer[]>]

    Returns Promise<Buffer[]>

  • Parameters

    • Rest...args: [numkeys: string | number, ...args: RedisValue[]]

    Returns Promise<Buffer[]>

  • Parameters

    • Rest...args: [numkeys: string | number, ...args: RedisValue[], withscores: "WITHSCORES", callback: Callback<Buffer[]>]

    Returns Promise<Buffer[]>

  • Parameters

    • Rest...args: [numkeys: string | number, ...args: RedisValue[], withscores: "WITHSCORES"]

    Returns Promise<Buffer[]>

  • Parameters

    • Rest...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<Buffer[]>]

    Returns Promise<Buffer[]>

  • Parameters

    • Rest...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM"]

    Returns Promise<Buffer[]>

  • Parameters

    • Rest...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES", callback: Callback<Buffer[]>]

    Returns Promise<Buffer[]>

  • Parameters

    • Rest...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM", withscores: "WITHSCORES"]

    Returns Promise<Buffer[]>

  • Parameters

    • Rest...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN", callback: Callback<Buffer[]>]

    Returns Promise<Buffer[]>

  • Parameters

    • Rest...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN"]

    Returns Promise<Buffer[]>

  • Parameters

    • Rest...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES", callback: Callback<Buffer[]>]

    Returns Promise<Buffer[]>

  • Parameters

    • Rest...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN", withscores: "WITHSCORES"]

    Returns Promise<Buffer[]>

  • Parameters

    • Rest...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX", callback: Callback<Buffer[]>]

    Returns Promise<Buffer[]>

  • Parameters

    • Rest...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX"]

    Returns Promise<Buffer[]>

  • Parameters

    • Rest...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES", callback: Callback<Buffer[]>]

    Returns Promise<Buffer[]>

  • Parameters

    • Rest...args: [numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX", withscores: "WITHSCORES"]

    Returns Promise<Buffer[]>

  • Add multiple sorted sets and store the resulting sorted set in a new key

    • group: sorted-set
    • complexity: O(N)+O(M log(M)) with N being the sum of the sizes of the input sorted sets, and M being the number of elements in the resulting sorted set.
    • since: 2.0.0

    Parameters

    • Rest...args: [destination: RedisKey, numkeys: string | number, ...keys: RedisKey[], callback: Callback<number>]

    Returns Promise<number>

  • Parameters

    • Rest...args: [destination: RedisKey, numkeys: string | number, keys: RedisKey[], callback: Callback<number>]

    Returns Promise<number>

  • Parameters

    • Rest...args: [destination: RedisKey, numkeys: string | number, ...keys: RedisKey[]]

    Returns Promise<number>

  • Parameters

    • Rest...args: [destination: RedisKey, numkeys: string | number, keys: RedisKey[]]

    Returns Promise<number>

  • Parameters

    • Rest...args: [destination: RedisKey, numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<number>]

    Returns Promise<number>

  • Parameters

    • Rest...args: [destination: RedisKey, numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<number>]

    Returns Promise<number>

  • Parameters

    • Rest...args: [destination: RedisKey, numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM"]

    Returns Promise<number>

  • Parameters

    • Rest...args: [destination: RedisKey, numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", sum: "SUM"]

    Returns Promise<number>

  • Parameters

    • Rest...args: [destination: RedisKey, numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", callback: Callback<number>]

    Returns Promise<number>

  • Parameters

    • Rest...args: [destination: RedisKey, numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN", callback: Callback<number>]

    Returns Promise<number>

  • Parameters

    • Rest...args: [destination: RedisKey, numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN"]

    Returns Promise<number>

  • Parameters

    • Rest...args: [destination: RedisKey, numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", min: "MIN"]

    Returns Promise<number>

  • Parameters

    • Rest...args: [destination: RedisKey, numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", callback: Callback<number>]

    Returns Promise<number>

  • Parameters

    • Rest...args: [destination: RedisKey, numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX", callback: Callback<number>]

    Returns Promise<number>

  • Parameters

    • Rest...args: [destination: RedisKey, numkeys: string | number, ...keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX"]

    Returns Promise<number>

  • Parameters

    • Rest...args: [destination: RedisKey, numkeys: string | number, keys: RedisKey[], aggregate: "AGGREGATE", max: "MAX"]

    Returns Promise<number>

  • Parameters

    • Rest...args: [destination: RedisKey, numkeys: string | number, ...args: RedisValue[], callback: Callback<number>]

    Returns Promise<number>

  • Parameters

    • Rest...args: [destination: RedisKey, numkeys: string | number, ...args: RedisValue[]]

    Returns Promise<number>

  • Parameters

    • Rest...args: [destination: RedisKey, numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM", callback: Callback<number>]

    Returns Promise<number>

  • Parameters

    • Rest...args: [destination: RedisKey, numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", sum: "SUM"]

    Returns Promise<number>

  • Parameters

    • Rest...args: [destination: RedisKey, numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN", callback: Callback<number>]

    Returns Promise<number>

  • Parameters

    • Rest...args: [destination: RedisKey, numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", min: "MIN"]

    Returns Promise<number>

  • Parameters

    • Rest...args: [destination: RedisKey, numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX", callback: Callback<number>]

    Returns Promise<number>

  • Parameters

    • Rest...args: [destination: RedisKey, numkeys: string | number, ...args: RedisValue[], aggregate: "AGGREGATE", max: "MAX"]

    Returns Promise<number>

  • Create a Redis instance. This is the same as new Redis() but is included for compatibility with node-redis.

    Parameters

    • Rest...args: []

    Returns Redis